nvidia-nat-a2a 1.5.0a20251229__py3-none-any.whl

nat/plugins/a2a/server/front_end_plugin.py

@@ -0,0 +1,122 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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.
+
+import logging
+
+import uvicorn
+
+from nat.builder.front_end import FrontEndBase
+from nat.builder.workflow_builder import WorkflowBuilder
+from nat.plugins.a2a.server.front_end_config import A2AFrontEndConfig
+from nat.plugins.a2a.server.front_end_plugin_worker import A2AFrontEndPluginWorker
+
+logger = logging.getLogger(__name__)
+
+
+class A2AFrontEndPlugin(FrontEndBase[A2AFrontEndConfig]):
+    """A2A front end plugin implementation.
+
+    Exposes NAT workflows as A2A-compliant remote agents that can be
+    discovered and invoked by other A2A agents and clients.
+    """
+
+    async def run(self) -> None:
+        """Run the A2A server.
+
+        This method:
+        1. Builds the workflow
+        2. Creates the agent card from configuration
+        3. Creates the agent executor adapter
+        4. Sets up the A2A server
+        5. Starts the server with uvicorn
+        """
+        # Build the workflow
+        async with WorkflowBuilder.from_config(config=self.full_config) as builder:
+            workflow = await builder.build()
+
+            # Create worker instance
+            worker = self._get_worker_instance()
+
+            # Build agent card from configuration and workflow functions
+            agent_card = await worker.create_agent_card(workflow)
+
+            # Create agent executor adapter
+            agent_executor = worker.create_agent_executor(workflow, builder)
+
+            # Create A2A server
+            a2a_server = worker.create_a2a_server(agent_card, agent_executor)
+
+            # Start the server with proper cleanup
+            try:
+                logger.info(
+                    "Starting A2A server '%s' at http://%s:%s",
+                    self.front_end_config.name,
+                    self.front_end_config.host,
+                    self.front_end_config.port,
+                )
+                logger.info("Agent card available at: http://%s:%s/.well-known/agent-card.json",
+                            self.front_end_config.host,
+                            self.front_end_config.port)
+
+                # Build the ASGI app
+                app = a2a_server.build()
+
+                # Add OAuth2 validation middleware if configured
+                if self.front_end_config.server_auth:
+                    from nat.plugins.a2a.server.oauth_middleware import OAuth2ValidationMiddleware
+
+                    app.add_middleware(OAuth2ValidationMiddleware, config=self.front_end_config.server_auth)
+                    logger.info(
+                        "OAuth2 token validation enabled for A2A server (issuer=%s, scopes=%s)",
+                        self.front_end_config.server_auth.issuer_url,
+                        self.front_end_config.server_auth.scopes,
+                    )
+
+                # Run with uvicorn
+                config = uvicorn.Config(
+                    app,
+                    host=self.front_end_config.host,
+                    port=self.front_end_config.port,
+                    log_level=self.front_end_config.log_level.lower(),
+                )
+                server = uvicorn.Server(config)
+                await server.serve()
+
+            except KeyboardInterrupt:
+                logger.info("A2A server shutdown requested (Ctrl+C). Shutting down gracefully.")
+            except Exception as e:
+                logger.error("A2A server error: %s", e, exc_info=True)
+                raise
+            finally:
+                # Ensure cleanup of resources (httpx client)
+                await worker.cleanup()
+                logger.info("A2A server resources cleaned up")
+
+    def _get_worker_instance(self) -> A2AFrontEndPluginWorker:
+        """Get an instance of the worker class.
+
+        Returns:
+            Worker instance configured with full config
+        """
+        # Check if custom worker class is specified
+        if self.front_end_config.runner_class:
+            module_name, class_name = self.front_end_config.runner_class.rsplit(".", 1)
+            import importlib
+            module = importlib.import_module(module_name)
+            worker_class = getattr(module, class_name)
+            return worker_class(self.full_config)
+
+        # Use default worker
+        return A2AFrontEndPluginWorker(self.full_config)

nat/plugins/a2a/server/front_end_plugin_worker.py

@@ -0,0 +1,306 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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.
+
+import logging
+
+import httpx
+
+from a2a.server.apps import A2AStarletteApplication
+from a2a.server.request_handlers import DefaultRequestHandler
+from a2a.server.tasks import BasePushNotificationSender
+from a2a.server.tasks import InMemoryPushNotificationConfigStore
+from a2a.server.tasks import InMemoryTaskStore
+from a2a.types import AgentCapabilities
+from a2a.types import AgentCard
+from a2a.types import AgentSkill
+from a2a.types import SecurityScheme
+from nat.builder.function import Function
+from nat.builder.workflow import Workflow
+from nat.builder.workflow_builder import WorkflowBuilder
+from nat.data_models.config import Config
+from nat.plugins.a2a.server.agent_executor_adapter import NATWorkflowAgentExecutor
+from nat.plugins.a2a.server.front_end_config import A2AFrontEndConfig
+from nat.runtime.session import SessionManager
+
+logger = logging.getLogger(__name__)
+
+
+class A2AFrontEndPluginWorker:
+    """Worker that handles A2A server setup and configuration."""
+
+    def __init__(self, config: Config):
+        """Initialize the A2A worker with configuration.
+
+        Args:
+            config: The full NAT configuration
+        """
+        self.full_config = config
+        self.front_end_config: A2AFrontEndConfig = config.general.front_end  # type: ignore
+
+        # Max concurrency for handling A2A tasks (from configuration)
+        # This limits how many workflow invocations can run simultaneously
+        self.max_concurrency = self.front_end_config.max_concurrency
+
+        # HTTP client for push notifications (managed for cleanup)
+        self._httpx_client: httpx.AsyncClient | None = None
+
+    async def _get_all_functions(self, workflow: Workflow) -> dict[str, Function]:
+        """Get all functions from the workflow.
+
+        Args:
+            workflow: The NAT workflow
+
+        Returns:
+            Dict mapping function names to Function objects
+        """
+        functions: dict[str, Function] = {}
+
+        # Extract all functions from the workflow
+        functions.update(workflow.functions)
+        for function_group in workflow.function_groups.values():
+            functions.update(await function_group.get_accessible_functions())
+
+        return functions
+
+    async def _generate_security_schemes(
+            self, server_auth_config) -> tuple[dict[str, SecurityScheme], list[dict[str, list[str]]]]:
+        """Generate A2A security schemes from OAuth2ResourceServerConfig.
+
+        Args:
+            server_auth_config: OAuth2ResourceServerConfig
+
+        Returns:
+            Tuple of (security_schemes dict, security requirements list)
+        """
+        from a2a.types import AuthorizationCodeOAuthFlow
+        from a2a.types import OAuth2SecurityScheme
+        from a2a.types import OAuthFlows
+
+        # Resolve OAuth2 endpoints from configuration
+        auth_url, token_url = await self._resolve_oauth_endpoints(server_auth_config)
+
+        # Create scope descriptions
+        scope_descriptions = {scope: f"Permission: {scope}" for scope in server_auth_config.scopes}
+
+        # Build OAuth2 security scheme
+        security_schemes = {
+            "oauth2":
+                SecurityScheme(root=OAuth2SecurityScheme(
+                    type="oauth2",
+                    description="OAuth 2.0 authentication required to access this agent",
+                    flows=OAuthFlows(authorizationCode=AuthorizationCodeOAuthFlow(
+                        authorizationUrl=auth_url,
+                        tokenUrl=token_url,
+                        scopes=scope_descriptions,
+                    )),
+                ))
+        }
+
+        # Security requirements (scopes needed)
+        security = [{"oauth2": server_auth_config.scopes}]
+
+        return security_schemes, security
+
+    async def _resolve_oauth_endpoints(self, server_auth_config) -> tuple[str, str]:
+        """Resolve authorization and token URLs from OAuth2 configuration.
+
+        Args:
+            server_auth_config: OAuth2ResourceServerConfig
+
+        Returns:
+            Tuple of (authorization_url, token_url)
+        """
+        import httpx
+
+        # If discovery URL is provided, use OIDC discovery
+        if server_auth_config.discovery_url:
+            try:
+                async with httpx.AsyncClient() as client:
+                    response = await client.get(server_auth_config.discovery_url, timeout=5.0)
+                    response.raise_for_status()
+                    metadata = response.json()
+
+                    auth_url = metadata.get("authorization_endpoint")
+                    token_url = metadata.get("token_endpoint")
+
+                    if auth_url and token_url:
+                        logger.info("Resolved OAuth endpoints via discovery: %s", server_auth_config.discovery_url)
+                        return auth_url, token_url
+            except Exception as e:
+                logger.warning("Failed to discover OAuth endpoints: %s", e)
+
+        # Fallback: derive from issuer URL (common convention)
+        issuer = server_auth_config.issuer_url.rstrip("/")
+        auth_url = f"{issuer}/oauth/authorize"
+        token_url = f"{issuer}/oauth/token"
+
+        logger.info("Using derived OAuth endpoints from issuer: %s", issuer)
+        return auth_url, token_url
+
+    async def create_agent_card(self, workflow: Workflow) -> AgentCard:
+        """Build AgentCard from configuration and workflow functions.
+
+        Skills are auto-generated from the workflow's functions, similar to how
+        MCP introspects and exposes functions as tools.
+
+        Args:
+            workflow: The NAT workflow to extract functions from
+
+        Returns:
+            AgentCard with agent metadata, capabilities, and auto-generated skills
+        """
+        config = self.front_end_config
+
+        # Build capabilities
+        capabilities = AgentCapabilities(
+            streaming=config.capabilities.streaming,
+            push_notifications=config.capabilities.push_notifications,
+        )
+
+        # Auto-generate skills from workflow functions
+        functions = await self._get_all_functions(workflow)
+        skills = []
+
+        for function_name, function in functions.items():
+            # Create skill from function metadata
+            skill_name = function_name.replace('_', ' ').replace('.', ' - ').title()
+            skill_description = function.description or f"Execute {function_name}"
+
+            skill = AgentSkill(
+                id=function_name,
+                name=skill_name,
+                description=skill_description,
+                tags=[],  # Could be extended with function metadata
+                examples=[],  # Could be extracted from function examples if available
+            )
+            skills.append(skill)
+
+        logger.info("Auto-generated %d skills from workflow functions", len(skills))
+
+        # Generate security schemes if server_auth is configured
+        security_schemes = None
+        security = None
+
+        if config.server_auth:
+            security_schemes, security = await self._generate_security_schemes(config.server_auth)
+            logger.info(
+                "Generated OAuth2 security schemes for agent (issuer=%s, scopes=%s)",
+                config.server_auth.issuer_url,
+                config.server_auth.scopes,
+            )
+
+        # Build agent card
+        agent_url = f"http://{config.host}:{config.port}/"
+        agent_card = AgentCard(
+            name=config.name,
+            description=config.description,
+            url=agent_url,
+            version=config.version,
+            default_input_modes=config.default_input_modes,
+            default_output_modes=config.default_output_modes,
+            capabilities=capabilities,
+            skills=skills,
+            security_schemes=security_schemes,
+            security=security,
+        )
+
+        logger.info("Created AgentCard for: %s v%s", config.name, config.version)
+        logger.info("Agent URL: %s", agent_url)
+        logger.info("Skills: %d", len(skills))
+        if security_schemes:
+            logger.info("Security: OAuth2 authentication required")
+
+        return agent_card
+
+    def create_agent_executor(self, workflow: Workflow, builder: WorkflowBuilder) -> NATWorkflowAgentExecutor:
+        """Create agent executor adapter for the workflow.
+
+        This creates a SessionManager to handle concurrent A2A task requests,
+        similar to how FastAPI handles multiple HTTP requests.
+
+        Args:
+            workflow: The NAT workflow to expose
+            builder: The workflow builder used to create the workflow
+
+        Returns:
+            NATWorkflowAgentExecutor that wraps the workflow with a SessionManager
+        """
+        # Create SessionManager to handle concurrent requests with proper limits
+        session_manager = SessionManager(
+            config=self.full_config,
+            shared_builder=builder,
+            shared_workflow=workflow,
+            max_concurrency=self.max_concurrency,
+        )
+
+        logger.info("Created SessionManager with max_concurrency=%d", self.max_concurrency)
+
+        return NATWorkflowAgentExecutor(session_manager)
+
+    def create_a2a_server(
+        self,
+        agent_card: AgentCard,
+        agent_executor: NATWorkflowAgentExecutor,
+    ) -> A2AStarletteApplication:
+        """Create A2A server with the agent executor.
+
+        Args:
+            agent_card: The agent card describing the agent
+            agent_executor: The executor that handles task processing
+
+        Returns:
+            Configured A2A Starlette application
+
+        Note:
+            The httpx client is stored in self._httpx_client for lifecycle management.
+            Call cleanup() during server shutdown to properly close the client.
+        """
+        # Create HTTP client for push notifications and store for cleanup
+        self._httpx_client = httpx.AsyncClient()
+
+        # Create push notification infrastructure
+        push_config_store = InMemoryPushNotificationConfigStore()
+        push_sender = BasePushNotificationSender(
+            httpx_client=self._httpx_client,
+            config_store=push_config_store,
+        )
+
+        # Create request handler
+        request_handler = DefaultRequestHandler(
+            agent_executor=agent_executor,
+            task_store=InMemoryTaskStore(),
+            push_config_store=push_config_store,
+            push_sender=push_sender,
+        )
+
+        # Create A2A server
+        server = A2AStarletteApplication(
+            agent_card=agent_card,
+            http_handler=request_handler,
+        )
+
+        logger.info("Created A2A server with DefaultRequestHandler")
+
+        return server
+
+    async def cleanup(self) -> None:
+        """Clean up resources, particularly the httpx client.
+
+        This should be called during server shutdown to prevent connection leaks.
+        """
+        if self._httpx_client is not None:
+            await self._httpx_client.aclose()
+            self._httpx_client = None
+            logger.info("Closed httpx client for push notifications")

nat/plugins/a2a/server/oauth_middleware.py

@@ -0,0 +1,121 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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.
+"""OAuth 2.0 token validation middleware for A2A servers."""
+
+import logging
+
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.requests import Request
+from starlette.responses import JSONResponse
+
+from nat.authentication.credential_validator.bearer_token_validator import BearerTokenValidator
+from nat.authentication.oauth2.oauth2_resource_server_config import OAuth2ResourceServerConfig
+
+logger = logging.getLogger(__name__)
+
+
+class OAuth2ValidationMiddleware(BaseHTTPMiddleware):
+    """OAuth2 Bearer token validation middleware for A2A servers.
+
+    Validates Bearer tokens using NAT's BearerTokenValidator which supports:
+    - JWT validation via JWKS (RFC 7519)
+    - Opaque token validation via introspection (RFC 7662)
+    - OIDC discovery
+    - Scope and audience enforcement
+
+    The middleware allows public access to the agent card discovery endpoint
+    (/.well-known/agent.json) and validates all other A2A requests.
+    """
+
+    def __init__(self, app, config: OAuth2ResourceServerConfig):
+        """Initialize OAuth2 validation middleware.
+
+        Args:
+            app: Starlette application
+            config: OAuth2 resource server configuration
+        """
+        super().__init__(app)
+
+        # Create validator using NAT's BearerTokenValidator
+        self.validator = BearerTokenValidator(
+            issuer=config.issuer_url,
+            audience=config.audience,
+            scopes=config.scopes,
+            jwks_uri=config.jwks_uri,
+            introspection_endpoint=config.introspection_endpoint,
+            discovery_url=config.discovery_url,
+            client_id=config.client_id,
+            client_secret=config.client_secret.get_secret_value() if config.client_secret else None,
+        )
+
+        logger.info(
+            "OAuth2 validation middleware initialized (issuer=%s, scopes=%s, audience=%s)",
+            config.issuer_url,
+            config.scopes,
+            config.audience,
+        )
+
+    async def dispatch(self, request: Request, call_next):
+        """Validate OAuth2 Bearer token for all requests except agent card discovery.
+
+        Args:
+            request: Incoming HTTP request
+            call_next: Next middleware/handler in chain
+
+        Returns:
+            HTTP response (either error or result from next handler)
+        """
+        # Public: Agent card discovery (per A2A spec)
+        if request.url.path == "/.well-known/agent-card.json":
+            logger.debug("Public access to agent card discovery")
+            return await call_next(request)
+
+        # Extract Bearer token
+        auth_header = request.headers.get("Authorization", "")
+        if not auth_header.startswith("Bearer "):
+            logger.warning("Missing or invalid Authorization header")
+            return JSONResponse({
+                "error": "unauthorized", "message": "Missing or invalid Bearer token"
+            },
+                                status_code=401)
+
+        token = auth_header[7:]  # Strip "Bearer "
+
+        # Validate token using NAT's validator
+        try:
+            result = await self.validator.verify(token)
+        except Exception as e:
+            logger.error(f"Token validation error: {e}")
+            return JSONResponse({"error": "invalid_token", "message": "Token validation failed"}, status_code=403)
+
+        # Check if token is active
+        if not result.active:
+            logger.warning("Token is not active")
+            return JSONResponse({"error": "invalid_token", "message": "Token is not active"}, status_code=403)
+
+        # Attach token info to request state for potential use by handlers
+        request.state.oauth_user = result.subject
+        request.state.oauth_scopes = result.scopes or []
+        request.state.oauth_client_id = result.client_id
+        request.state.oauth_token_info = result
+
+        logger.debug(
+            "Token validated successfully (user=%s, scopes=%s, client=%s)",
+            result.subject,
+            result.scopes,
+            result.client_id,
+        )
+
+        return await call_next(request)

nat/plugins/a2a/server/register_frontend.py

@@ -0,0 +1,37 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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.
+"""Registration of A2A front end with NAT plugin system."""
+
+from collections.abc import AsyncIterator
+
+from nat.cli.register_workflow import register_front_end
+from nat.data_models.config import Config
+from nat.plugins.a2a.server.front_end_config import A2AFrontEndConfig
+
+
+@register_front_end(config_type=A2AFrontEndConfig)
+async def register_a2a_front_end(_config: A2AFrontEndConfig, full_config: Config) -> AsyncIterator:
+    """Register the A2A front end plugin.
+
+    Args:
+        _config: The A2A front end configuration (unused, provided for registration)
+        full_config: The complete NAT configuration
+
+    Yields:
+        A2AFrontEndPlugin instance
+    """
+    from nat.plugins.a2a.server.front_end_plugin import A2AFrontEndPlugin
+
+    yield A2AFrontEndPlugin(full_config=full_config)

nvidia_nat_a2a-1.5.0a20251229.dist-info/METADATA

@@ -0,0 +1,57 @@
+Metadata-Version: 2.4
+Name: nvidia-nat-a2a
+Version: 1.5.0a20251229
+Summary: Subpackage for A2A Protocol integration in NeMo Agent Toolkit
+Author: NVIDIA Corporation
+Maintainer: NVIDIA Corporation
+License: Apache-2.0
+Project-URL: documentation, https://docs.nvidia.com/nemo/agent-toolkit/latest/
+Project-URL: source, https://github.com/NVIDIA/NeMo-Agent-Toolkit
+Keywords: ai,rag,agents,a2a
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: <3.14,>=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: nvidia-nat==v1.5.0a20251229
+Requires-Dist: a2a-sdk~=0.3.20
+Dynamic: license-file
+
+<!--
+SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+SPDX-License-Identifier: Apache-2.0
+
+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.
+-->
+
+![NVIDIA NeMo Agent Toolkit](https://media.githubusercontent.com/media/NVIDIA/NeMo-Agent-Toolkit/refs/heads/main/docs/source/_static/banner.png "NeMo Agent toolkit banner image")
+
+
+# NVIDIA NeMo Agent Toolkit A2A Subpackage
+Subpackage for A2A Protocol integration in NeMo Agent toolkit.
+
+This package provides A2A (Agent-to-Agent) Protocol functionality, allowing NeMo Agent toolkit workflows to connect to remote A2A agents and invoke their skills as functions. This package includes both the client and server components of the A2A protocol.
+
+## Features
+### Client
+- Connect to remote A2A agents via HTTP with JSON-RPC transport
+- Discover agent capabilities through Agent Cards
+- Submit tasks to remote agents with async execution
+
+### Server
+- Serve A2A agents via HTTP with JSON-RPC transport
+- Support for A2A agent executor pattern
+
+For more information about the NVIDIA NeMo Agent Toolkit, please visit the [NeMo Agent Toolkit GitHub Repo](https://github.com/NVIDIA/NeMo-Agent-Toolkit).

nvidia_nat_a2a-1.5.0a20251229.dist-info/RECORD

@@ -0,0 +1,22 @@
+nat/meta/pypi.md,sha256=YkfjzZntzheoaBie5ZovnAwB78xxVqk9sblkZRZcdLU,1661
+nat/plugins/a2a/__init__.py,sha256=GUJrgGtpvyMUCjUBvR3faAdv-tZzbU9W-izgx9aMEQg,680
+nat/plugins/a2a/register.py,sha256=pUN1hbJ38M8GbdNcA0qQzJ1S-ZC91GnRGk_8SO_kTVg,853
+nat/plugins/a2a/auth/__init__.py,sha256=iQFx1YrjFcepS7k8jp93A0IVOkFeNx_I35M6dIngoJA,726
+nat/plugins/a2a/auth/credential_service.py,sha256=-_VdDF4YESaAtY1ONUiOL5z4aGDJZYVuhyhI9BZhuyI,15967
+nat/plugins/a2a/client/__init__.py,sha256=GUJrgGtpvyMUCjUBvR3faAdv-tZzbU9W-izgx9aMEQg,680
+nat/plugins/a2a/client/client_base.py,sha256=xShDZDFKa4R2XsY3yBMvM-eDaf_0cdE48XJzQ4WcEOw,13366
+nat/plugins/a2a/client/client_config.py,sha256=KwWjymDg9GUfSYcIaBhcxph4Hu6IeTe414hrNUUo-6g,2875
+nat/plugins/a2a/client/client_impl.py,sha256=CGAjiHr6EyWcnlSipmT8ixgjD4s8VbPRBPOZy2q_Sm0,12958
+nat/plugins/a2a/server/__init__.py,sha256=GUJrgGtpvyMUCjUBvR3faAdv-tZzbU9W-izgx9aMEQg,680
+nat/plugins/a2a/server/agent_executor_adapter.py,sha256=wvGXOb3FcV0_pYRv-yr-QzozjzXM909D49Dxm9199xI,7015
+nat/plugins/a2a/server/front_end_config.py,sha256=Lg-qjDmC4fwrwnHNtSRl54pMpdwVnO06xhgbLt-aEZY,4902
+nat/plugins/a2a/server/front_end_plugin.py,sha256=fX3Lagkd48snSiNo2IMTRpR-40WHUWQidpjKu8uQChY,4896
+nat/plugins/a2a/server/front_end_plugin_worker.py,sha256=Ehdv6lyUcrWkfMq7YomD4NYFAusrtQ2JYj2HnkIqGhY,11696
+nat/plugins/a2a/server/oauth_middleware.py,sha256=NvvIJSPB8wRui2eQlxr6AaNhN0JxdUQ1Ajr8Dnk0rnY,4751
+nat/plugins/a2a/server/register_frontend.py,sha256=4TmpBcZF4x71c2xnWuketsygqHmU7D2hKA2bzO34TpU,1480
+nvidia_nat_a2a-1.5.0a20251229.dist-info/licenses/LICENSE.md,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
+nvidia_nat_a2a-1.5.0a20251229.dist-info/METADATA,sha256=uHbXjyUGN9TADzyHyZgf4PZpkBHpV8uIX6euqTNhPFM,2438
+nvidia_nat_a2a-1.5.0a20251229.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nvidia_nat_a2a-1.5.0a20251229.dist-info/entry_points.txt,sha256=Lacvy6nXpDTv8dh8vKJ_QE8TobliVdhgABuw25t8fBg,145
+nvidia_nat_a2a-1.5.0a20251229.dist-info/top_level.txt,sha256=8-CJ2cP6-f0ZReXe5Hzqp-5pvzzHz-5Ds5H2bGqh1-U,4
+nvidia_nat_a2a-1.5.0a20251229.dist-info/RECORD,,

nvidia_nat_a2a-1.5.0a20251229.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

nvidia_nat_a2a-1.5.0a20251229.dist-info/entry_points.txt

@@ -0,0 +1,5 @@
+[nat.components]
+nat_a2a_client = nat.plugins.a2a.client.client_impl
+
+[nat.front_ends]
+nat_a2a_server = nat.plugins.a2a.server.register_frontend