@aws/nx-plugin 1.0.0-rc.4 → 1.0.0-rc.41

package/src/py/agent/files/a2a-langchain/main.py.template

@@ -0,0 +1,89 @@
+import logging
+import os
+import uuid
+
+from a2a.server.agent_execution import AgentExecutor, RequestContext
+from a2a.server.apps import A2AStarletteApplication
+from a2a.server.events import EventQueue
+from a2a.server.request_handlers import DefaultRequestHandler
+from a2a.server.tasks import InMemoryTaskStore, TaskUpdater
+from a2a.types import AgentCapabilities, AgentCard, Part, TextPart
+from a2a.utils import new_task
+from fastapi import FastAPI, Request
+from starlette.middleware.base import BaseHTTPMiddleware
+
+from <%- agentConnectionModuleName %> import get_current_session_id, session_id_context
+
+from .agent import get_agent
+
+logging.basicConfig(level=logging.INFO)
+
+PORT = int(os.environ.get("PORT", "9000"))
+RUNTIME_URL = os.environ.get("AGENTCORE_RUNTIME_URL", f"http://localhost:{PORT}/")
+SESSION_ID_HEADER = "x-amzn-bedrock-agentcore-runtime-session-id"
+DEFAULT_MODES = ["text/plain"]
+
+_graph = get_agent()
+
+
+class _GraphAgentExecutor(AgentExecutor):
+    async def execute(self, context: RequestContext, event_queue: EventQueue) -> None:
+        if context.message is None:
+            raise ValueError("A2A request is missing a message")
+        task = context.current_task or new_task(context.message)
+        await event_queue.enqueue_event(task)
+        updater = TaskUpdater(event_queue, task.id, task.context_id)
+        await updater.start_work()
+        # The session bound by the middleware drives the LangGraph thread, keeping
+        # checkpointed conversation state separate per caller session.
+        session_id = get_current_session_id() or task.context_id
+        result = await _graph.ainvoke(
+            {"messages": [{"role": "user", "content": context.get_user_input()}]},
+            {"configurable": {"thread_id": session_id}},
+        )
+        reply = result["messages"][-1].content
+        await updater.add_artifact([Part(TextPart(kind="text", text=reply))])
+        await updater.complete()
+
+    async def cancel(self, context: RequestContext, event_queue: EventQueue) -> None:
+        raise NotImplementedError("Cancellation is not supported.")
+
+
+_handler = DefaultRequestHandler(
+    agent_executor=_GraphAgentExecutor(),
+    task_store=InMemoryTaskStore(),
+)
+
+_agent_card = AgentCard(
+    name="<%= agentNameClassName %>",
+    description="A LangChain/LangGraph Agent exposed via the Agent-to-Agent (A2A) protocol.",
+    url=RUNTIME_URL,
+    version="1.0.0",
+    default_input_modes=DEFAULT_MODES,
+    default_output_modes=DEFAULT_MODES,
+    capabilities=AgentCapabilities(streaming=True),
+    skills=[],
+)
+
+a2a_app = A2AStarletteApplication(agent_card=_agent_card, http_handler=_handler).build()
+
+
+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 = FastAPI(title="<%= agentNameClassName %>")
+app.add_middleware(_SessionIdMiddleware)
+
+
+@app.get("/ping")
+def ping() -> dict[str, str]:
+    return {"status": "Healthy"}
+
+
+app.mount("/", a2a_app)

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

@@ -0,0 +1,83 @@
+import logging
+import time
+import uuid
+
+from ag_ui.core import EventType, RunAgentInput, RunErrorEvent
+from ag_ui.encoder import EventEncoder
+from ag_ui_langgraph import LangGraphAgent
+from fastapi import FastAPI, Request
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse, StreamingResponse
+from <%- agentConnectionModuleName %> import get_current_session_id, session_id_context
+from starlette.middleware.base import BaseHTTPMiddleware
+
+from .agent import get_agent
+
+logging.basicConfig(level=logging.INFO)
+
+SESSION_ID_HEADER = "x-amzn-bedrock-agentcore-runtime-session-id"
+
+_graph = get_agent()
+
+agui_agent = LangGraphAgent(
+    name="<%= agentNameClassName %>",
+    graph=_graph,
+    description="A LangChain/LangGraph Agent exposed via the AG-UI protocol.",
+)
+
+
+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)
+
+
+app = FastAPI(title="<%= agentNameClassName %>")
+# Allow browser-based AG-UI clients (e.g. a connected React website) to call
+# this agent cross-origin, including the CORS preflight.
+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.
+    accept = request.headers.get("accept") or ""
+    encoder = EventEncoder(accept=accept)
+    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())):
+            try:
+                async for event in agui_agent.run(input_data):
+                    yield encoder.encode(event)
+            except Exception as e:
+                yield encoder.encode(RunErrorEvent(type=EventType.RUN_ERROR, message=str(e)[:300], code="AGENT_ERROR"))
+
+    return StreamingResponse(event_generator(), media_type=encoder.get_content_type())
+
+
+@app.get("/ping")
+async def ping():
+    return JSONResponse({"status": "Healthy", "time_of_last_update": int(time.time())})

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

@@ -2,6 +2,7 @@ from contextlib import contextmanager
 
 from strands import Agent, tool
 from strands_tools import current_time
+from <%- agentConnectionModuleName %> import log_model_errors
 
 
 @tool
@@ -20,4 +21,5 @@ Use your tools for mathematical tasks.
 Refer to tools as your 'spellbook'.
 """,
         tools=[subtract, current_time],
+        hooks=[log_model_errors],
     )

package/src/py/agent/files/common-langchain/agent.py.template

@@ -0,0 +1,30 @@
+import os
+
+from langchain.agents import create_agent
+from langchain_aws import ChatBedrockConverse
+from langchain_core.tools import tool
+from langgraph.checkpoint.memory import InMemorySaver
+
+REGION = os.environ.get("AWS_REGION", "us-east-1")
+MODEL_ID = os.environ.get("MODEL_ID", "global.anthropic.claude-haiku-4-5-20251001-v1:0")
+
+
+@tool
+def subtract(a: int, b: int) -> int:
+    """Subtract b from a."""
+    return a - b
+
+
+def get_agent():
+    model = ChatBedrockConverse(model=MODEL_ID, region_name=REGION)
+    # Swap InMemorySaver for a durable checkpointer in a multi-replica deployment.
+    return create_agent(
+        model=model,
+        tools=[subtract],
+        system_prompt="""
+You are a mathematical wizard.
+Use your tools for mathematical tasks.
+Refer to tools as your 'spellbook'.
+""",
+        checkpointer=InMemorySaver(),
+    )

package/src/py/agent/files/deploy/Dockerfile.template

@@ -1,4 +1,4 @@
-FROM public.ecr.aws/docker/library/python:3.14-slim
+FROM <%- pythonBaseImage %>
 
 WORKDIR /app
 

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

@@ -1,11 +1,10 @@
+import logging
 from collections.abc import AsyncIterator
 from typing import Any
 
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
-from fastapi.openapi.utils import get_openapi
 from fastapi.responses import JSONResponse, StreamingResponse
-from fastapi.routing import APIRoute
 from pydantic import BaseModel
 from starlette.middleware.exceptions import ExceptionMiddleware
 
@@ -61,7 +60,11 @@ class JsonStreamingResponse(StreamingResponse):
         }
 
 
-app = FastAPI(title="<%= agentNameClassName %>", responses={500: {"model": InternalServerErrorDetails}})
+app = FastAPI(
+    title="<%= agentNameClassName %>",
+    responses={500: {"model": InternalServerErrorDetails}},
+    generate_unique_id_function=lambda route: route.name,
+)
 
 # Add cors middleware
 app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_methods=["*"], allow_headers=["*"])
@@ -72,28 +75,7 @@ app.add_middleware(ExceptionMiddleware, handlers=app.exception_handlers)
 
 @app.exception_handler(Exception)
 async def unhandled_exception_handler(request, err):
-    print(request)
-    print(err)
+    logging.exception("Unhandled exception while handling request")
     return JSONResponse(
         status_code=500, content=InternalServerErrorDetails(detail="Internal Server Error").model_dump()
     )
-
-
-def custom_openapi() -> dict[str, Any]:
-    if app.openapi_schema:
-        return app.openapi_schema
-    for route in app.routes:
-        if isinstance(route, APIRoute):
-            route.operation_id = route.name
-    openapi_schema = get_openapi(
-        title=app.title,
-        version=app.version,
-        openapi_version=app.openapi_version,
-        description=app.description,
-        routes=app.routes,
-    )
-    app.openapi_schema = openapi_schema
-    return app.openapi_schema
-
-
-app.openapi = custom_openapi  # ty: ignore[invalid-assignment]

package/src/py/agent/files/http/main.py.template

@@ -3,7 +3,7 @@ import uuid
 import uvicorn
 from bedrock_agentcore.runtime.models import PingStatus
 from fastapi import Request
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 from starlette.middleware.base import BaseHTTPMiddleware
 from <%- agentConnectionModuleName %> import session_id_context, with_session_id
 
@@ -21,7 +21,7 @@ _agent = _agent_ctx.__enter__()
 
 
 class InvokeInput(BaseModel):
-    message: str
+    prompt: str = Field(max_length=100000)
 
 
 class StreamChunk(BaseModel):
@@ -30,9 +30,8 @@ class StreamChunk(BaseModel):
 
 async def handle_invoke(input: InvokeInput):
     """Streaming handler for agent invocation"""
-    stream = _agent.stream_async(input.message)
+    stream = _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)

package/src/py/agent/files/http-langchain/main.py.template

@@ -0,0 +1,84 @@
+import uuid
+
+import uvicorn
+from bedrock_agentcore.runtime.models import PingStatus
+from fastapi import Request
+from pydantic import BaseModel, Field
+from starlette.middleware.base import BaseHTTPMiddleware
+from <%- agentConnectionModuleName %> import get_current_session_id, session_id_context
+
+from .agent import get_agent
+from .init import JsonStreamingResponse, app
+
+SESSION_ID_HEADER = "x-amzn-bedrock-agentcore-runtime-session-id"
+
+_graph = get_agent()
+
+
+class InvokeInput(BaseModel):
+    prompt: str = Field(max_length=100000)
+
+
+class StreamChunk(BaseModel):
+    content: str
+
+
+def _text(content) -> str:
+    # ChatBedrockConverse streams content as a list of blocks, not a plain string.
+    if isinstance(content, str):
+        return content
+    return "".join(
+        block.get("text", "")
+        for block in content
+        if isinstance(block, dict) and block.get("type") == "text"
+    )
+
+
+async def handle_invoke(input: InvokeInput, session_id: str):
+    """Streaming handler for agent invocation"""
+    # The session id is the LangGraph thread id, so the checkpointer keeps memory per session.
+    config = {"configurable": {"thread_id": session_id}}
+    # Re-bind the session: the streaming body runs outside the middleware scope.
+    with session_id_context(session_id):
+        stream = _graph.astream(
+            {"messages": [{"role": "user", "content": input.prompt}]},
+            config,
+            stream_mode="messages",
+        )
+        async for message_chunk, _metadata in stream:
+            text = _text(message_chunk.content)
+            if text:
+                yield StreamChunk(content=text)
+
+
+@app.post(
+    "/invocations",
+    response_class=JsonStreamingResponse,
+    responses={200: JsonStreamingResponse.openapi_response(StreamChunk, "Stream of agent response chunks")},
+)
+async def invoke(input: InvokeInput) -> JsonStreamingResponse:
+    """Entry point for agent invocation"""
+    session_id = get_current_session_id() or str(uuid.uuid4())
+    return JsonStreamingResponse(handle_invoke(input, session_id))
+
+
+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.get("/ping")
+def ping() -> str:
+    # TODO: if running an async task, return PingStatus.HEALTHY_BUSY
+    return PingStatus.HEALTHY
+
+
+if __name__ == "__main__":
+    uvicorn.run("<%- moduleName %>.<%- agentNameSnakeCase %>.main:app", port=8080)

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,10 @@
+/**
+ * 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 NxGeneratorInfo } from '../../../utils/nx';
+import type { PyAgentGatewayConnectionGeneratorSchema } from './schema';
+export declare const PY_AGENT_GATEWAY_CONNECTION_GENERATOR_INFO: NxGeneratorInfo;
+export declare const pyAgentGatewayConnectionGenerator: (tree: Tree, options: PyAgentGatewayConnectionGeneratorSchema) => Promise<GeneratorCallback>;
+export default pyAgentGatewayConnectionGenerator;