@aws/nx-plugin 1.0.0-rc.7 → 1.0.0-rc.71

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

@@ -3,25 +3,17 @@ 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
+from <%- agentConnectionModuleName %> import session_id_context
 
-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__()
-
 
 class InvokeInput(BaseModel):
-    message: str
+    prompt: str = Field(max_length=100000)
 
 
 class StreamChunk(BaseModel):
@@ -30,9 +22,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)

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';
+import { type NxGeneratorInfo } from '../../../utils/nx';
+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").DependencyDeclaration<readonly import("../../../utils/declared-dependencies").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;

package/src/py/agent/gateway-connection/generator.js

@@ -0,0 +1,153 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */ import { generateFiles, joinPathFragments, OverwriteStrategy, updateProjectConfiguration } from "@nx/devkit";
+import { readAgentCoreGatewayMetadata } from "../../../agentcore-gateway/generator.js";
+import { addPyDependencies } from "../../../utils/add-dependencies.js";
+import { AGENT_CONNECTION_PY_DEPENDENCIES, addPythonCoreClient, addPythonReExport, ensurePythonAgentConnectionProject, getPythonAgentConnectionModuleName, getPythonAgentConnectionProject, getPythonAgentConnectionProjectDir, PY_MCP_FAMILY_CONNECTIONS, resolveAgentFramework } from "../../../utils/agent-connection/agent-connection.js";
+import { addPythonDestructuredImport } from "../../../utils/ast.js";
+import { declareDependencies, ownedElsewhere } from "../../../utils/declared-dependencies.js";
+import { formatFilesInSubtree } from "../../../utils/format.js";
+import { installDependencies } from "../../../utils/install.js";
+import { addGeneratorMetricsIfApplicable } from "../../../utils/metrics.js";
+import { snakeCase } from "../../../utils/names.js";
+import { addComponentGeneratorMetadata, addDependencyToTargetIfNotPresent, getGeneratorInfo, readProjectConfigurationUnqualified } from "../../../utils/nx.js";
+import { toProjectRelativePath } from "../../../utils/paths.js";
+import { addWorkspaceDependencyToPyProject } from "../../../utils/py.js";
+// The framework picks the MCP client's extra deps, so it names its branch here.
+export const DEPENDENCIES = declareDependencies()({
+    py: [
+        {
+            name: 'boto3'
+        },
+        {
+            name: 'httpx'
+        },
+        {
+            name: 'mcp'
+        },
+        // Backs the LangChain client; it must not pull Strands in.
+        {
+            name: 'langchain-mcp-adapters',
+            when: (m)=>m.framework === 'langchain'
+        },
+        ...ownedElsewhere(AGENT_CONNECTION_PY_DEPENDENCIES)
+    ]
+});
+export const PY_AGENT_GATEWAY_CONNECTION_GENERATOR_INFO = getGeneratorInfo(import.meta.filename);
+export const pyAgentGatewayConnectionGenerator = async (tree, options)=>{
+    const sourceProject = readProjectConfigurationUnqualified(tree, options.sourceProject);
+    const targetProject = readProjectConfigurationUnqualified(tree, options.targetProject);
+    const agentComponent = options.sourceComponent;
+    if (!agentComponent) {
+        throw new Error('sourceComponent must be provided for py#agent -> agentcore-gateway connections');
+    }
+    const gateway = readAgentCoreGatewayMetadata(targetProject);
+    if (gateway.protocol !== 'mcp') {
+        throw new Error(`Gateway '${gateway.name}' has protocol='${gateway.protocol}'. Only MCP-protocol gateways are supported.`);
+    }
+    if (gateway.auth !== 'iam') {
+        throw new Error(`Gateway '${gateway.name}' uses auth='${gateway.auth}'. Agent connections currently require the gateway to use IAM authentication.`);
+    }
+    if (agentComponent.auth && agentComponent.auth !== 'iam') {
+        throw new Error(`Agent '${agentComponent.name}' uses auth='${agentComponent.auth}'. Only IAM-authenticated agents can connect to IAM gateways.`);
+    }
+    const gatewayClassName = gateway.rc;
+    const gatewaySnakeCase = snakeCase(gatewayClassName);
+    // A gateway is its own standalone project, so it exposes plain serve / dev.
+    const gatewayServeTargetName = 'serve';
+    const gatewayDevTargetName = 'dev';
+    // The source agent's framework selects the client shape, dependencies and the
+    // agent.py transform — see PY_MCP_FAMILY_CONNECTIONS (keyed by framework, not a
+    // boolean, so a third framework is an additive entry there). A Gateway exposes
+    // its tools over MCP, so it reuses the same wiring as an MCP server connection.
+    const framework = resolveAgentFramework(agentComponent.framework);
+    const connection = PY_MCP_FAMILY_CONNECTIONS[framework];
+    // Recorded below and read by the declaration's predicates, so the packages
+    // added here are exactly the ones the version sync will own.
+    const metadata = {
+        framework
+    };
+    await ensurePythonAgentConnectionProject(tree, DEPENDENCIES);
+    await addPythonCoreClient(tree, 'gateway', DEPENDENCIES, framework);
+    const agentConnectionProjectDir = getPythonAgentConnectionProjectDir(tree);
+    const agentConnectionModuleName = getPythonAgentConnectionModuleName(tree);
+    // Shared MCP transport + signed httpx auth deps, plus whatever extra deps the
+    // framework's MCP client needs (e.g. langchain-mcp-adapters for LangChain).
+    // These belong to the shared agent-connection project, which holds the client.
+    addPyDependencies(tree, DEPENDENCIES, {
+        metadata,
+        projectRoot: agentConnectionProjectDir
+    });
+    const appDir = joinPathFragments(agentConnectionProjectDir, agentConnectionModuleName, 'app');
+    // Local mode points at the gateway project's local gateway port.
+    generateFiles(tree, joinPathFragments(import.meta.dirname, 'files', connection.appTemplateSubdir), appDir, {
+        gatewaySnakeCase,
+        gatewayClassName,
+        agentConnectionModuleName,
+        gatewayPort: gateway.port
+    }, {
+        overwriteStrategy: OverwriteStrategy.KeepExisting
+    });
+    const appInitPath = joinPathFragments(appDir, '__init__.py');
+    if (!tree.exists(appInitPath)) {
+        tree.write(appInitPath, '');
+    }
+    const moduleInitPath = joinPathFragments(agentConnectionProjectDir, agentConnectionModuleName, '__init__.py');
+    await addPythonReExport(tree, moduleInitPath, `.app.${gatewaySnakeCase}_client_${connection.clientModuleSuffix}`, `${gatewayClassName}Client${connection.clientClassSuffix}`);
+    const agentSourceDir = joinPathFragments(sourceProject.root, agentComponent.path ?? 'src');
+    const agentFilePath = joinPathFragments(agentSourceDir, 'agent.py');
+    if (tree.exists(agentFilePath)) {
+        const clientClassName = `${gatewayClassName}Client${connection.clientClassSuffix}`;
+        const clientVarName = gatewaySnakeCase;
+        await addPythonDestructuredImport(tree, agentFilePath, [
+            clientClassName
+        ], agentConnectionModuleName);
+        await connection.wireClientIntoAgent(tree, agentFilePath, clientClassName, clientVarName);
+    }
+    addWorkspaceDependencyToPyProject(tree, sourceProject, getPythonAgentConnectionProject(tree));
+    const agentName = agentComponent.name ?? 'agent';
+    const serveTargetName = `${agentName}-serve`;
+    const devTargetName = `${agentName}-dev`;
+    let projectConfigChanged = false;
+    if (sourceProject.targets?.[serveTargetName]) {
+        addDependencyToTargetIfNotPresent(sourceProject, serveTargetName, {
+            projects: [
+                targetProject.name
+            ],
+            target: gatewayServeTargetName
+        });
+        projectConfigChanged = true;
+    }
+    if (sourceProject.targets?.[devTargetName]) {
+        addDependencyToTargetIfNotPresent(sourceProject, devTargetName, {
+            projects: [
+                targetProject.name
+            ],
+            target: gatewayDevTargetName
+        });
+        projectConfigChanged = true;
+    }
+    if (projectConfigChanged) {
+        updateProjectConfiguration(tree, sourceProject.name, sourceProject);
+    }
+    // Recorded so the version sync knows this connection's dependencies are ours.
+    addComponentGeneratorMetadata(tree, sourceProject.name, PY_AGENT_GATEWAY_CONNECTION_GENERATOR_INFO, toProjectRelativePath(sourceProject, agentFilePath), gatewayClassName, // `sourcePath` names the source component this connection is made from, so
+    // the pair is identifiable rather than just the two projects.
+    {
+        ...metadata,
+        sourcePath: options.sourceComponent?.path
+    });
+    await addGeneratorMetricsIfApplicable(tree, [
+        PY_AGENT_GATEWAY_CONNECTION_GENERATOR_INFO
+    ]);
+    await formatFilesInSubtree(tree);
+    return ()=>installDependencies(tree, options.preferInstallDependencies, {
+            languages: [
+                'typescript'
+            ]
+        });
+};
+export default pyAgentGatewayConnectionGenerator;
+
+//# sourceMappingURL=generator.js.map

package/src/py/agent/gateway-connection/generator.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../packages/nx-plugin/src/py/agent/gateway-connection/generator.ts"],"sourcesContent":["/**\n * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n * SPDX-License-Identifier: Apache-2.0\n */\nimport {\n  type GeneratorCallback,\n  generateFiles,\n  joinPathFragments,\n  OverwriteStrategy,\n  type Tree,\n  updateProjectConfiguration,\n} from '@nx/devkit';\nimport { readAgentCoreGatewayMetadata } from '../../../agentcore-gateway/generator';\nimport { addPyDependencies } from '../../../utils/add-dependencies';\nimport {\n  AGENT_CONNECTION_PY_DEPENDENCIES,\n  type AgentFramework,\n  addPythonCoreClient,\n  addPythonReExport,\n  ensurePythonAgentConnectionProject,\n  getPythonAgentConnectionModuleName,\n  getPythonAgentConnectionProject,\n  getPythonAgentConnectionProjectDir,\n  PY_MCP_FAMILY_CONNECTIONS,\n  resolveAgentFramework,\n} from '../../../utils/agent-connection/agent-connection';\nimport { addPythonDestructuredImport } from '../../../utils/ast';\nimport {\n  declareDependencies,\n  ownedElsewhere,\n} from '../../../utils/declared-dependencies';\nimport { formatFilesInSubtree } from '../../../utils/format';\nimport { installDependencies } from '../../../utils/install';\nimport { addGeneratorMetricsIfApplicable } from '../../../utils/metrics';\nimport { snakeCase } from '../../../utils/names';\nimport {\n  addComponentGeneratorMetadata,\n  addDependencyToTargetIfNotPresent,\n  getGeneratorInfo,\n  type NxGeneratorInfo,\n  readProjectConfigurationUnqualified,\n} from '../../../utils/nx';\nimport { toProjectRelativePath } from '../../../utils/paths';\nimport { addWorkspaceDependencyToPyProject } from '../../../utils/py';\nimport type { PyAgentGatewayConnectionGeneratorSchema } from './schema';\n\n/** The metadata this generator records, which its predicates read. */\nexport interface PyAgentGatewayConnectionMetadata {\n  readonly framework: AgentFramework;\n}\n\n// The framework picks the MCP client's extra deps, so it names its branch here.\nexport const DEPENDENCIES =\n  declareDependencies<PyAgentGatewayConnectionMetadata>()({\n    py: [\n      { name: 'boto3' },\n      { name: 'httpx' },\n      { name: 'mcp' },\n      // Backs the LangChain client; it must not pull Strands in.\n      {\n        name: 'langchain-mcp-adapters',\n        when: (m) => m.framework === 'langchain',\n      },\n      ...ownedElsewhere(AGENT_CONNECTION_PY_DEPENDENCIES),\n    ],\n  });\n\nexport const PY_AGENT_GATEWAY_CONNECTION_GENERATOR_INFO: NxGeneratorInfo =\n  getGeneratorInfo(import.meta.filename);\n\nexport const pyAgentGatewayConnectionGenerator = async (\n  tree: Tree,\n  options: PyAgentGatewayConnectionGeneratorSchema,\n): Promise<GeneratorCallback> => {\n  const sourceProject = readProjectConfigurationUnqualified(\n    tree,\n    options.sourceProject,\n  );\n  const targetProject = readProjectConfigurationUnqualified(\n    tree,\n    options.targetProject,\n  );\n\n  const agentComponent = options.sourceComponent;\n  if (!agentComponent) {\n    throw new Error(\n      'sourceComponent must be provided for py#agent -> agentcore-gateway connections',\n    );\n  }\n  const gateway = readAgentCoreGatewayMetadata(targetProject);\n\n  if (gateway.protocol !== 'mcp') {\n    throw new Error(\n      `Gateway '${gateway.name}' has protocol='${gateway.protocol}'. Only MCP-protocol gateways are supported.`,\n    );\n  }\n  if (gateway.auth !== 'iam') {\n    throw new Error(\n      `Gateway '${gateway.name}' uses auth='${gateway.auth}'. Agent connections currently require the gateway to use IAM authentication.`,\n    );\n  }\n  if (agentComponent.auth && agentComponent.auth !== 'iam') {\n    throw new Error(\n      `Agent '${agentComponent.name}' uses auth='${agentComponent.auth}'. Only IAM-authenticated agents can connect to IAM gateways.`,\n    );\n  }\n\n  const gatewayClassName = gateway.rc;\n  const gatewaySnakeCase = snakeCase(gatewayClassName);\n  // A gateway is its own standalone project, so it exposes plain serve / dev.\n  const gatewayServeTargetName = 'serve';\n  const gatewayDevTargetName = 'dev';\n\n  // The source agent's framework selects the client shape, dependencies and the\n  // agent.py transform — see PY_MCP_FAMILY_CONNECTIONS (keyed by framework, not a\n  // boolean, so a third framework is an additive entry there). A Gateway exposes\n  // its tools over MCP, so it reuses the same wiring as an MCP server connection.\n  const framework = resolveAgentFramework(agentComponent.framework);\n  const connection = PY_MCP_FAMILY_CONNECTIONS[framework];\n\n  // Recorded below and read by the declaration's predicates, so the packages\n  // added here are exactly the ones the version sync will own.\n  const metadata: PyAgentGatewayConnectionMetadata = { framework };\n\n  await ensurePythonAgentConnectionProject(tree, DEPENDENCIES);\n  await addPythonCoreClient(tree, 'gateway', DEPENDENCIES, framework);\n\n  const agentConnectionProjectDir = getPythonAgentConnectionProjectDir(tree);\n  const agentConnectionModuleName = getPythonAgentConnectionModuleName(tree);\n\n  // Shared MCP transport + signed httpx auth deps, plus whatever extra deps the\n  // framework's MCP client needs (e.g. langchain-mcp-adapters for LangChain).\n  // These belong to the shared agent-connection project, which holds the client.\n  addPyDependencies(tree, DEPENDENCIES, {\n    metadata,\n    projectRoot: agentConnectionProjectDir,\n  });\n\n  const appDir = joinPathFragments(\n    agentConnectionProjectDir,\n    agentConnectionModuleName,\n    'app',\n  );\n  // Local mode points at the gateway project's local gateway port.\n  generateFiles(\n    tree,\n    joinPathFragments(\n      import.meta.dirname,\n      'files',\n      connection.appTemplateSubdir,\n    ),\n    appDir,\n    {\n      gatewaySnakeCase,\n      gatewayClassName,\n      agentConnectionModuleName,\n      gatewayPort: gateway.port,\n    },\n    { overwriteStrategy: OverwriteStrategy.KeepExisting },\n  );\n\n  const appInitPath = joinPathFragments(appDir, '__init__.py');\n  if (!tree.exists(appInitPath)) {\n    tree.write(appInitPath, '');\n  }\n\n  const moduleInitPath = joinPathFragments(\n    agentConnectionProjectDir,\n    agentConnectionModuleName,\n    '__init__.py',\n  );\n  await addPythonReExport(\n    tree,\n    moduleInitPath,\n    `.app.${gatewaySnakeCase}_client_${connection.clientModuleSuffix}`,\n    `${gatewayClassName}Client${connection.clientClassSuffix}`,\n  );\n\n  const agentSourceDir = joinPathFragments(\n    sourceProject.root,\n    agentComponent.path ?? 'src',\n  );\n  const agentFilePath = joinPathFragments(agentSourceDir, 'agent.py');\n\n  if (tree.exists(agentFilePath)) {\n    const clientClassName = `${gatewayClassName}Client${connection.clientClassSuffix}`;\n    const clientVarName = gatewaySnakeCase;\n\n    await addPythonDestructuredImport(\n      tree,\n      agentFilePath,\n      [clientClassName],\n      agentConnectionModuleName,\n    );\n    await connection.wireClientIntoAgent(\n      tree,\n      agentFilePath,\n      clientClassName,\n      clientVarName,\n    );\n  }\n\n  addWorkspaceDependencyToPyProject(\n    tree,\n    sourceProject,\n    getPythonAgentConnectionProject(tree),\n  );\n\n  const agentName = agentComponent.name ?? 'agent';\n  const serveTargetName = `${agentName}-serve`;\n  const devTargetName = `${agentName}-dev`;\n  let projectConfigChanged = false;\n  if (sourceProject.targets?.[serveTargetName]) {\n    addDependencyToTargetIfNotPresent(sourceProject, serveTargetName, {\n      projects: [targetProject.name],\n      target: gatewayServeTargetName,\n    });\n    projectConfigChanged = true;\n  }\n  if (sourceProject.targets?.[devTargetName]) {\n    addDependencyToTargetIfNotPresent(sourceProject, devTargetName, {\n      projects: [targetProject.name],\n      target: gatewayDevTargetName,\n    });\n    projectConfigChanged = true;\n  }\n  if (projectConfigChanged) {\n    updateProjectConfiguration(tree, sourceProject.name, sourceProject);\n  }\n\n  // Recorded so the version sync knows this connection's dependencies are ours.\n  addComponentGeneratorMetadata(\n    tree,\n    sourceProject.name,\n    PY_AGENT_GATEWAY_CONNECTION_GENERATOR_INFO,\n    toProjectRelativePath(sourceProject, agentFilePath),\n    gatewayClassName,\n    // `sourcePath` names the source component this connection is made from, so\n    // the pair is identifiable rather than just the two projects.\n    { ...metadata, sourcePath: options.sourceComponent?.path },\n  );\n\n  await addGeneratorMetricsIfApplicable(tree, [\n    PY_AGENT_GATEWAY_CONNECTION_GENERATOR_INFO,\n  ]);\n\n  await formatFilesInSubtree(tree);\n  return () =>\n    installDependencies(tree, options.preferInstallDependencies, {\n      languages: ['typescript'],\n    });\n};\n\nexport default pyAgentGatewayConnectionGenerator;\n"],"names":["generateFiles","joinPathFragments","OverwriteStrategy","updateProjectConfiguration","readAgentCoreGatewayMetadata","addPyDependencies","AGENT_CONNECTION_PY_DEPENDENCIES","addPythonCoreClient","addPythonReExport","ensurePythonAgentConnectionProject","getPythonAgentConnectionModuleName","getPythonAgentConnectionProject","getPythonAgentConnectionProjectDir","PY_MCP_FAMILY_CONNECTIONS","resolveAgentFramework","addPythonDestructuredImport","declareDependencies","ownedElsewhere","formatFilesInSubtree","installDependencies","addGeneratorMetricsIfApplicable","snakeCase","addComponentGeneratorMetadata","addDependencyToTargetIfNotPresent","getGeneratorInfo","readProjectConfigurationUnqualified","toProjectRelativePath","addWorkspaceDependencyToPyProject","DEPENDENCIES","py","name","when","m","framework","PY_AGENT_GATEWAY_CONNECTION_GENERATOR_INFO","filename","pyAgentGatewayConnectionGenerator","tree","options","sourceProject","targetProject","agentComponent","sourceComponent","Error","gateway","protocol","auth","gatewayClassName","rc","gatewaySnakeCase","gatewayServeTargetName","gatewayDevTargetName","connection","metadata","agentConnectionProjectDir","agentConnectionModuleName","projectRoot","appDir","dirname","appTemplateSubdir","gatewayPort","port","overwriteStrategy","KeepExisting","appInitPath","exists","write","moduleInitPath","clientModuleSuffix","clientClassSuffix","agentSourceDir","root","path","agentFilePath","clientClassName","clientVarName","wireClientIntoAgent","agentName","serveTargetName","devTargetName","projectConfigChanged","targets","projects","target","sourcePath","preferInstallDependencies","languages"],"mappings":"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"}

package/src/py/agent/gateway-connection/schema.d.js

@@ -0,0 +1,6 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */ export { };
+
+//# sourceMappingURL=schema.d.js.map

package/src/py/agent/gateway-connection/schema.d.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../packages/nx-plugin/src/py/agent/gateway-connection/schema.d.ts"],"sourcesContent":["/**\n * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n * SPDX-License-Identifier: Apache-2.0\n */\nimport type { ComponentMetadata } from '../../../utils/nx';\n\nexport interface PyAgentGatewayConnectionGeneratorSchema {\n  sourceProject: string;\n  targetProject: string;\n  sourceComponent?: ComponentMetadata;\n  targetComponent?: ComponentMetadata;\n  preferInstallDependencies?: boolean;\n}\n"],"names":[],"mappings":"AAAA;;;CAGC,GAGD,WAMC"}

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

@@ -0,0 +1,13 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { ComponentMetadata } from '../../../utils/nx';
+
+export interface PyAgentGatewayConnectionGeneratorSchema {
+  sourceProject: string;
+  targetProject: string;
+  sourceComponent?: ComponentMetadata;
+  targetComponent?: ComponentMetadata;
+  preferInstallDependencies?: boolean;
+}