@aws/nx-plugin 1.0.0-rc.8 → 1.0.0-rc.80

package/src/py/agent/files/strands/ag-ui/main.py.template

@@ -0,0 +1,86 @@
+import logging
+import uuid
+from contextlib import asynccontextmanager
+
+from ag_ui.core import EventType, RunAgentInput, RunErrorEvent
+from ag_ui.encoder import EventEncoder
+from ag_ui_strands import StrandsAgent, StrandsAgentConfig
+from fastapi import FastAPI, Request
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import StreamingResponse
+from <%- agentConnectionModuleName %> import get_current_session_id, session_id_context
+
+from .agent import AGENT_HOOKS, get_agent
+from .middleware.session_id_middleware import SESSION_ID_HEADER, SessionIdMiddleware
+from .session import get_session_manager
+
+logging.basicConfig(level=logging.INFO)
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    with get_agent() as agent:
+        app.state.agui_agent = StrandsAgent(
+            agent=agent,
+            name="<%= agentNameClassName %>",
+            description="A Strands Agent exposed via the AG-UI protocol.",
+            # A per-thread session manager, not the template Agent's own, since
+            # AG-UI caches one Strands agent per thread_id.
+            config=StrandsAgentConfig(session_manager_provider=lambda _input_data: get_session_manager()),
+            # Required as well as on the template Agent: AG-UI keeps only the
+            # built HookRegistry, so hooks it can't read back are never
+            # registered and model/tool failures go unreported.
+            hooks=AGENT_HOOKS,
+        )
+        yield
+
+
+app = FastAPI(title="AWS Strands - <%= agentNameClassName %>", lifespan=lifespan)
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+app.add_middleware(SessionIdMiddleware)
+
+
+@app.post("/invocations")
+async def invocations(request: Request):
+    # Validate the body manually since AgentCore may omit Content-Type.
+    encoder = EventEncoder(accept=request.headers.get("accept") or "")
+    raw = await request.body()
+    try:
+        input_data = RunAgentInput.model_validate_json(raw)
+    except Exception as exc:
+        message = f"Invalid RunAgentInput: {str(exc)[:200]}"
+
+        async def _bad():
+            yield encoder.encode(RunErrorEvent(type=EventType.RUN_ERROR, message=message, code="BAD_REQUEST"))
+
+        return StreamingResponse(_bad(), media_type=encoder.get_content_type())
+
+    session_id = request.headers.get(SESSION_ID_HEADER) or get_current_session_id()
+
+    async def event_generator():
+        # Re-bind the session: the streaming body runs outside the middleware.
+        with session_id_context(session_id or str(uuid.uuid4())):
+            async for event in request.app.state.agui_agent.run(input_data):
+                try:
+                    yield encoder.encode(event)
+                except Exception as e:
+                    error_event = RunErrorEvent(
+                        type=EventType.RUN_ERROR,
+                        message=f"Encoding error: {e}",
+                        code="ENCODING_ERROR",
+                    )
+                    yield encoder.encode(error_event)
+                    break
+
+    return StreamingResponse(event_generator(), media_type=encoder.get_content_type())
+
+
+@app.get("/ping")
+async def ping():
+    return {"status": "healthy"}

package/src/py/agent/files/{common → strands/common}/agent.py.template

@@ -1,7 +1,13 @@
 from contextlib import contextmanager
 
 from strands import Agent, tool
+from strands.hooks import HookCallback, HookProvider
 from strands_tools import current_time
+from <%- agentConnectionModuleName %> import log_model_errors, log_tool_errors
+<%_ if (protocol !== 'ag-ui') { _%>
+
+from .session import get_session_manager
+<%_ } _%>
 
 
 @tool
@@ -9,6 +15,9 @@ def subtract(a: int, b: int) -> int:
     return a - b
 
 
+AGENT_HOOKS: list[HookProvider | HookCallback] = [log_model_errors, log_tool_errors]
+
+
 @contextmanager
 def get_agent():
     yield Agent(
@@ -20,4 +29,8 @@ Use your tools for mathematical tasks.
 Refer to tools as your 'spellbook'.
 """,
         tools=[subtract, current_time],
+        hooks=AGENT_HOOKS,
+<%_ if (protocol !== 'ag-ui') { _%>
+        session_manager=get_session_manager(),
+<%_ } _%>
     )

package/src/py/agent/files/strands/common/middleware/session_id_middleware.py.template

@@ -0,0 +1,17 @@
+import uuid
+
+from fastapi import Request
+from starlette.middleware.base import BaseHTTPMiddleware
+
+from <%- agentConnectionModuleName %> import session_id_context
+
+SESSION_ID_HEADER = "x-amzn-bedrock-agentcore-runtime-session-id"
+
+
+class SessionIdMiddleware(BaseHTTPMiddleware):
+    """Bind the session ID for this request so downstream MCP / A2A clients forward it on outbound calls."""
+
+    async def dispatch(self, request: Request, call_next):
+        session_id = request.headers.get(SESSION_ID_HEADER) or str(uuid.uuid4())
+        with session_id_context(session_id):
+            return await call_next(request)

package/src/py/agent/files/strands/common/session.py.template

@@ -0,0 +1,36 @@
+import os
+
+from strands.session import FileSessionManager, SessionManager<% if (session === 's3') { %>, S3SessionManager<% } %>
+
+from <%- agentConnectionModuleName %> import get_current_session_id
+<%_ if (session === 's3') { _%>
+from <%- agentConnectionModuleName %>.core.runtime_config import get_agentcore_runtime_config
+<%_ } _%>
+
+
+def get_session_manager() -> SessionManager | None:
+    """Returns a SessionManager for persisting conversation state across
+    invocations. Local development always uses local file storage for
+    convenience, regardless of the configured session option. Without a
+    configured session option, conversation state is kept in memory only and
+    does not survive process restarts.
+    """
+    session_id = get_current_session_id()
+    if not session_id:
+        raise RuntimeError(
+            "No current session id — cannot resolve a SessionManager outside of a request scope."
+        )
+    if os.environ.get("LOCAL_DEV") == "true":
+        return FileSessionManager(session_id=session_id, storage_dir="<%- localSessionsDir %>")
+
+<%_ if (session === 's3') { _%>
+    config = get_agentcore_runtime_config()
+    bucket_name = (
+        (config.get("agentRuntimes") or {}).get("<%- agentNameClassName %>", {}).get("session", {}).get("bucketName")
+    )
+    if not bucket_name:
+        raise RuntimeError("No S3 bucket configured for this agent's session in runtime configuration.")
+    return S3SessionManager(session_id=session_id, bucket=bucket_name)
+<%_ } else { _%>
+    return None
+<%_ } _%>

package/src/py/agent/files/strands/http/init.py.template

@@ -0,0 +1,97 @@
+import logging
+from collections.abc import AsyncIterator
+from contextlib import asynccontextmanager
+from typing import Any
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse, StreamingResponse
+from <%- agentConnectionModuleName %> import with_session_id
+from pydantic import BaseModel
+from starlette.middleware.exceptions import ExceptionMiddleware
+
+from .agent import get_agent
+
+
+class InternalServerErrorDetails(BaseModel):
+    detail: str
+
+
+class JsonStreamingResponse(StreamingResponse):
+    """A streaming response that serializes items to JSON Lines format."""
+
+    media_type = "application/jsonl"
+
+    def __init__(
+        self,
+        content: AsyncIterator[BaseModel],
+        status_code: int = 200,
+        headers: dict[str, str] | None = None,
+        **kwargs: Any,
+    ) -> None:
+        """Stream json lines from an async iterator yielding Pydantic models"""
+        super().__init__(
+            content=self._serialize(content),
+            status_code=status_code,
+            headers=headers,
+            media_type=self.media_type,
+            **kwargs,
+        )
+
+    @staticmethod
+    async def _serialize(
+        content: AsyncIterator[BaseModel],
+    ) -> AsyncIterator[bytes]:
+        """Serialize Pydantic models to JSON Lines format."""
+        async for item in content:
+            yield (item.model_dump_json() + "\n").encode("utf-8")
+
+    @staticmethod
+    def openapi_response(
+        item_model: type[BaseModel],
+        description: str = "Streaming response",
+    ) -> dict[str, Any]:
+        """Generate an OpenAPI application/jsonl response for a stream of the given model"""
+        return {
+            "description": description,
+            "content": {
+                "application/jsonl": {
+                    "itemSchema": {"$ref": f"#/components/schemas/{item_model.__name__}"},
+                }
+            },
+            # Include the model so FastAPI registers the schema in components/schemas
+            "model": item_model,
+        }
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    with with_session_id(
+        get_agent,
+        name="<%= agentNameClassName %>",
+        description="A Strands Agent exposed via HTTP streaming.",
+    ) as agent:
+        app.state.agent = agent
+        yield
+
+
+app = FastAPI(
+    title="<%= agentNameClassName %>",
+    responses={500: {"model": InternalServerErrorDetails}},
+    generate_unique_id_function=lambda route: route.name,
+    lifespan=lifespan,
+)
+
+# Add cors middleware
+app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_methods=["*"], allow_headers=["*"])
+
+# Add exception middleware(s)
+app.add_middleware(ExceptionMiddleware, handlers=app.exception_handlers)
+
+
+@app.exception_handler(Exception)
+async def unhandled_exception_handler(request, err):
+    logging.exception("Unhandled exception while handling request")
+    return JSONResponse(
+        status_code=500, content=InternalServerErrorDetails(detail="Internal Server Error").model_dump()
+    )

package/src/py/agent/files/{http → strands/http}/main.py.template

@@ -1,27 +1,13 @@
-import uuid
-
 import uvicorn
 from bedrock_agentcore.runtime.models import PingStatus
-from fastapi import Request
-from pydantic import BaseModel
-from starlette.middleware.base import BaseHTTPMiddleware
-from <%- agentConnectionModuleName %> import session_id_context, with_session_id
+from pydantic import BaseModel, Field
 
-from .agent import get_agent
 from .init import JsonStreamingResponse, app
-
-SESSION_ID_HEADER = "x-amzn-bedrock-agentcore-runtime-session-id"
-
-_agent_ctx = with_session_id(
-    get_agent,
-    name="<%= agentNameClassName %>",
-    description="A Strands Agent exposed via HTTP streaming.",
-)
-_agent = _agent_ctx.__enter__()
+from .middleware.session_id_middleware import SessionIdMiddleware
 
 
 class InvokeInput(BaseModel):
-    message: str
+    prompt: str = Field(max_length=100000)
 
 
 class StreamChunk(BaseModel):
@@ -30,9 +16,8 @@ class StreamChunk(BaseModel):
 
 async def handle_invoke(input: InvokeInput):
     """Streaming handler for agent invocation"""
-    stream = _agent.stream_async(input.message)
+    stream = app.state.agent.stream_async(input.prompt)
     async for event in stream:
-        print(event)
         text = event.get("event", {}).get("contentBlockDelta", {}).get("delta", {}).get("text")
         if text is not None:
             yield StreamChunk(content=text)
@@ -50,16 +35,7 @@ async def invoke(input: InvokeInput) -> JsonStreamingResponse:
     return JsonStreamingResponse(handle_invoke(input))
 
 
-class _SessionIdMiddleware(BaseHTTPMiddleware):
-    """Bind the inbound session (or a fresh UUID) to async context."""
-
-    async def dispatch(self, request: Request, call_next):
-        session_id = request.headers.get(SESSION_ID_HEADER) or str(uuid.uuid4())
-        with session_id_context(session_id):
-            return await call_next(request)
-
-
-app.add_middleware(_SessionIdMiddleware)
+app.add_middleware(SessionIdMiddleware)
 
 
 @app.get("/ping")

package/src/py/agent/gateway-connection/__snapshots__/generator.spec.ts.snap

@@ -0,0 +1,184 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`py#agent#gateway-connection generator > should match snapshot for agent-connection core files > agentcore_gateway_mcp_client_strands.py 1`] = `
+"from strands.tools.mcp.mcp_client import MCPClient
+
+from .agentcore_gateway_mcp_transport import AgentCoreGatewayMCPTransport
+
+
+class AgentCoreGatewayMCPClientStrands:
+    """Factory for Strands MCP clients that connect to an AgentCore Gateway."""
+
+    @staticmethod
+    def with_iam_auth(
+        gateway_url: str,
+        region: str | None = None,
+    ) -> MCPClient:
+        """Create a gateway MCP client authenticated with IAM SigV4."""
+        return MCPClient(AgentCoreGatewayMCPTransport.with_iam_auth(gateway_url, region))
+
+    @staticmethod
+    def without_auth(gateway_url: str) -> MCPClient:
+        """Plain-HTTP gateway client, for the local gateway started by the dev target."""
+        return MCPClient(AgentCoreGatewayMCPTransport.without_auth(gateway_url))
+"
+`;
+
+exports[`py#agent#gateway-connection generator > should match snapshot for agent-connection core files > agentcore_gateway_mcp_transport.py 1`] = `
+"from .agentcore_endpoints import region_from_gateway_url
+from .agentcore_transport import (
+    TransportFactory,
+    no_auth_transport,
+    sigv4_transport,
+)
+
+
+class AgentCoreGatewayMCPTransport:
+    """Factory for MCP transport factories that connect to an AgentCore Gateway.
+    Forwards the current async-context session via the AgentCore session header,
+    which the gateway propagates to downstream MCP server targets.
+    """
+
+    @staticmethod
+    def with_iam_auth(
+        gateway_url: str,
+        region: str | None = None,
+    ) -> TransportFactory:
+        """Create a gateway MCP transport authenticated with IAM SigV4."""
+        return sigv4_transport(gateway_url, region or region_from_gateway_url(gateway_url))
+
+    @staticmethod
+    def without_auth(gateway_url: str) -> TransportFactory:
+        """Plain-HTTP gateway transport, for the local gateway started by the dev target."""
+        return no_auth_transport(gateway_url)
+"
+`;
+
+exports[`py#agent#gateway-connection generator > should match snapshot for agent-connection core files > agentcore_transport.py 1`] = `
+"from collections.abc import Callable
+from typing import Any
+
+import boto3
+from mcp.client.streamable_http import streamablehttp_client
+
+from .auth.session import jwt_auth, plain_auth, sigv4_auth
+
+# Agent frameworks wrap a transport *factory* — a no-arg callable returning a
+# streamable-HTTP transport context manager. Typed as \`\`Any\`\` so this layer
+# stays free of any framework-specific transport type.
+TransportFactory = Callable[[], Any]
+
+
+def _factory(url: str, auth) -> TransportFactory:
+    return lambda: streamablehttp_client(
+        url,
+        auth=auth,
+        timeout=120,
+        terminate_on_close=False,
+    )
+
+
+def sigv4_transport(url: str, region: str) -> TransportFactory:
+    """SigV4-signed transport factory for a resolved AgentCore endpoint."""
+    credentials = boto3.Session(region_name=region).get_credentials()
+    return _factory(url, sigv4_auth(credentials, region))
+
+
+def jwt_transport(url: str, access_token_provider: Callable[[], str]) -> TransportFactory:
+    """Bearer-token transport factory for a resolved AgentCore endpoint."""
+    return _factory(url, jwt_auth(access_token_provider))
+
+
+def no_auth_transport(url: str) -> TransportFactory:
+    """Plain-HTTP transport factory — for local dev."""
+    return _factory(url, plain_auth())
+"
+`;
+
+exports[`py#agent#gateway-connection generator > should match snapshot for agent-connection core files > my_gateway_client_strands.py 1`] = `
+"import os
+
+from strands.tools.mcp.mcp_client import MCPClient
+
+from proj_agent_connection.core.agentcore_gateway_mcp_client_strands import (
+    AgentCoreGatewayMCPClientStrands,
+)
+from proj_agent_connection.core.runtime_config import (
+    get_agentcore_runtime_config,
+)
+
+
+class MyGatewayClientStrands:
+    """Strands client for the MyGateway AgentCore Gateway.
+
+    Deployed: a SigV4-signed MCP client pointing at the gateway URL.
+    Local (\`\`LOCAL_DEV=true\`\`): a plain-HTTP client pointing at the local
+    gateway started by the gateway project's dev target. The local
+    gateway aggregates every attached MCP server but does not evaluate
+    Cedar policies.
+    """
+
+    @staticmethod
+    def create() -> MCPClient:
+        if os.environ.get("LOCAL_DEV") == "true":
+            return AgentCoreGatewayMCPClientStrands.without_auth(gateway_url="http://localhost:8100/mcp")
+        config = get_agentcore_runtime_config()
+        gateway_url = config.get("gateways", {}).get("MyGateway")
+        if not gateway_url:
+            raise RuntimeError("No connected gateway named 'MyGateway' found in runtime configuration.")
+        return AgentCoreGatewayMCPClientStrands.with_iam_auth(gateway_url=gateway_url)
+"
+`;
+
+exports[`py#agent#gateway-connection generator > should match snapshot for agent-connection core files > session.py 1`] = `
+"from collections.abc import Callable
+
+import httpx
+
+from ..session_context import get_current_session_id
+from .sigv4 import SigV4HTTPXAuth
+
+SESSION_HEADER = "X-Amzn-Bedrock-AgentCore-Runtime-Session-Id"
+
+
+class SessionHeaderAuth(httpx.Auth):
+    """Stamps the AgentCore session header from the current async context,
+    then delegates to an optional inner auth (e.g. SigV4)."""
+
+    requires_request_body = True
+    requires_response_body = True
+
+    def __init__(self, inner: httpx.Auth | None = None):
+        self._inner = inner
+
+    def auth_flow(self, request: httpx.Request):  # type: ignore[override]
+        sid = get_current_session_id()
+        if sid:
+            request.headers[SESSION_HEADER] = sid
+        if self._inner is None:
+            yield request
+            return
+        yield from self._inner.auth_flow(request)
+
+
+def sigv4_auth(credentials, region: str, service: str = "bedrock-agentcore") -> httpx.Auth:
+    """Session-forwarding SigV4 auth (per-request, body-aware)."""
+    return SessionHeaderAuth(SigV4HTTPXAuth(credentials, service, region))
+
+
+def jwt_auth(access_token_provider: Callable[[], str]) -> httpx.Auth:
+    """Session-forwarding bearer-token auth."""
+
+    class _Bearer(httpx.Auth):
+        def auth_flow(self, request: httpx.Request):
+            request.headers["Authorization"] = f"Bearer {access_token_provider()}"
+            yield request
+
+    return SessionHeaderAuth(_Bearer())
+
+
+def plain_auth() -> httpx.Auth:
+    """Session-forwarding plain auth — for local dev."""
+    return SessionHeaderAuth()
+"
+`;

package/src/py/agent/gateway-connection/files/agent-connection/app/__gatewaySnakeCase___client_strands.py.template

@@ -0,0 +1,35 @@
+import os
+
+from strands.tools.mcp.mcp_client import MCPClient
+
+from <%- agentConnectionModuleName %>.core.agentcore_gateway_mcp_client_strands import (
+    AgentCoreGatewayMCPClientStrands,
+)
+from <%- agentConnectionModuleName %>.core.runtime_config import (
+    get_agentcore_runtime_config,
+)
+
+
+class <%- gatewayClassName %>ClientStrands:
+    """Strands client for the <%- gatewayClassName %> AgentCore Gateway.
+
+    Deployed: a SigV4-signed MCP client pointing at the gateway URL.
+    Local (``LOCAL_DEV=true``): a plain-HTTP client pointing at the local
+    gateway started by the gateway project's dev target. The local
+    gateway aggregates every attached MCP server but does not evaluate
+    Cedar policies.
+    """
+
+    @staticmethod
+    def create() -> MCPClient:
+        if os.environ.get("LOCAL_DEV") == "true":
+            return AgentCoreGatewayMCPClientStrands.without_auth(
+                gateway_url="http://localhost:<%- gatewayPort %>/mcp"
+            )
+        config = get_agentcore_runtime_config()
+        gateway_url = config.get("gateways", {}).get("<%- gatewayClassName %>")
+        if not gateway_url:
+            raise RuntimeError(
+                "No connected gateway named '<%- gatewayClassName %>' found in runtime configuration."
+            )
+        return AgentCoreGatewayMCPClientStrands.with_iam_auth(gateway_url=gateway_url)

package/src/py/agent/gateway-connection/files/langchain/agent-connection/app/__gatewaySnakeCase___client_langchain.py.template

@@ -0,0 +1,34 @@
+import os
+
+from langchain_core.tools import BaseTool
+
+from <%- agentConnectionModuleName %>.core.agentcore_gateway_mcp_client_langchain import (
+    AgentCoreGatewayMCPClientLangChain,
+)
+from <%- agentConnectionModuleName %>.core.runtime_config import (
+    get_agentcore_runtime_config,
+)
+
+
+class <%- gatewayClassName %>ClientLangChain:
+    """Loads LangChain tools from the <%- gatewayClassName %> AgentCore Gateway.
+
+    Deployed: SigV4-signed tools pointing at the gateway URL. Local
+    (``LOCAL_DEV=true``): plain-HTTP tools pointing at the local gateway
+    started by the gateway project's dev target. The local gateway
+    aggregates every attached MCP server but does not evaluate Cedar policies.
+    """
+
+    @staticmethod
+    def create() -> list[BaseTool]:
+        if os.environ.get("LOCAL_DEV") == "true":
+            return AgentCoreGatewayMCPClientLangChain.without_auth(
+                gateway_url="http://localhost:<%- gatewayPort %>/mcp"
+            )
+        config = get_agentcore_runtime_config()
+        gateway_url = config.get("gateways", {}).get("<%- gatewayClassName %>")
+        if not gateway_url:
+            raise RuntimeError(
+                "No connected gateway named '<%- gatewayClassName %>' found in runtime configuration."
+            )
+        return AgentCoreGatewayMCPClientLangChain.with_iam_auth(gateway_url=gateway_url)

package/src/py/agent/gateway-connection/generator.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { type GeneratorCallback, type Tree } from '@nx/devkit';
+import { type AgentFramework } from '../../../utils/agent-connection/agent-connection.js';
+import { type NxGeneratorInfo } from '../../../utils/nx.js';
+import type { PyAgentGatewayConnectionGeneratorSchema } from './schema';
+/** The metadata this generator records, which its predicates read. */
+export interface PyAgentGatewayConnectionMetadata {
+    readonly framework: AgentFramework;
+}
+export declare const DEPENDENCIES: import("../../../utils/declared-dependencies.js").DependencyDeclaration<readonly import("../../../utils/declared-dependencies.js").DeclaredTsDependency<"@a2a-js/sdk" | "@aws/aws-distro-opentelemetry-node-autoinstrumentation" | "@opentelemetry/propagator-jaeger" | "minimatch" | "@aws-sdk/client-dynamodb" | "@aws-sdk/client-api-gateway" | "@aws-sdk/client-iam" | "@aws-sdk/client-bedrock-agentcore" | "@aws-sdk/client-bedrock-runtime" | "@aws-sdk/client-s3" | "@aws-sdk/client-sts" | "@aws-sdk/credential-providers" | "@aws-sdk/credential-provider-cognito-identity" | "@aws-sdk/client-secrets-manager" | "@aws-sdk/rds-signer" | "@smithy/server-apigateway" | "@smithy/server-node" | "@aws-lambda-powertools/logger" | "@aws-lambda-powertools/metrics" | "@aws-lambda-powertools/parameters" | "@aws-lambda-powertools/tracer" | "@aws-lambda-powertools/parser" | "@aws-sdk/client-appconfigdata" | "@middy/core" | "@nxlv/python" | "@nx-extend/terraform" | "nx" | "@nx/devkit" | "@nx/js" | "@nx/react" | "@nx/vite" | "@nx/vitest" | "@nx/workspace" | "create-nx-workspace" | "@swc-node/register" | "@swc/core" | "@modelcontextprotocol/sdk" | "@modelcontextprotocol/inspector" | "@ag-ui/a2ui-toolkit" | "@ag-ui/aws-strands" | "@ag-ui/client" | "@ag-ui/core" | "@ag-ui/encoder" | "agent-chat-cli" | "@copilotkit/react-core" | "rxjs" | "@strands-agents/sdk" | "@tanstack/react-router" | "@tanstack/router-plugin" | "@tanstack/router-generator" | "@tanstack/virtual-file-routes" | "@tanstack/router-utils" | "@cloudscape-design/board-components" | "@cloudscape-design/chat-components" | "@cloudscape-design/components" | "@cloudscape-design/global-styles" | "@tanstack/react-query" | "@tanstack/react-query-devtools" | "@trpc/tanstack-react-query" | "@trpc/client" | "@trpc/server" | "@types/node" | "@types/aws-lambda" | "@types/cors" | "@types/pg" | "@types/ws" | "@types/express" | "@smithy/config-resolver" | "@smithy/node-config-provider" | "@smithy/node-http-handler" | "@smithy/types" | "@vitest/coverage-v8" | "@vitest/ui" | "@astrojs/react" | "@astrojs/starlight" | "astro" | "aws4fetch" | "aws-cdk" | "aws-cdk-lib" | "aws-xray-sdk-core" | "constructs" | "cors" | "chalk" | "class-variance-authority" | "clsx" | "commander" | "cpy-cli" | "electrodb" | "esbuild" | "event-source-polyfill" | "@types/event-source-polyfill" | "@biomejs/biome" | "@prisma/adapter-mariadb" | "@prisma/adapter-pg" | "@prisma/client" | "ejs" | "@types/ejs" | "express" | "fast-glob" | "husky" | "fs-extra" | "@types/fs-extra" | "make-dir-cli" | "mariadb" | "mise" | "ncp" | "npm" | "npm-check-updates" | "oidc-client-ts" | "pg" | "prisma" | "react-oidc-context" | "react" | "react-dom" | "rimraf" | "rolldown" | "rolldown-plugin-dts" | "simple-git" | "source-map-support" | "starlight-blog" | "tailwindcss" | "@tailwindcss/vite" | "tsx" | "lucide-react" | "radix-ui" | "shadcn" | "tw-animate-css" | "tailwind-merge" | "vite" | "typescript" | "vitest" | "zod" | "ws", PyAgentGatewayConnectionMetadata>[], readonly [{
+    readonly name: "boto3";
+}, {
+    readonly name: "httpx";
+}, {
+    readonly name: "mcp";
+}, {
+    readonly name: "langchain-mcp-adapters";
+    readonly when: (m: PyAgentGatewayConnectionMetadata) => boolean;
+}, {
+    readonly name: "aws-lambda-powertools";
+} & {
+    versionOnly: true;
+}, {
+    readonly name: "strands-agents";
+} & {
+    versionOnly: true;
+}]>;
+export declare const PY_AGENT_GATEWAY_CONNECTION_GENERATOR_INFO: NxGeneratorInfo;
+export declare const pyAgentGatewayConnectionGenerator: (tree: Tree, options: PyAgentGatewayConnectionGeneratorSchema) => Promise<GeneratorCallback>;
+export default pyAgentGatewayConnectionGenerator;