@aws/nx-plugin 0.42.1 → 0.44.0

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

@@ -0,0 +1,375 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`py#strands-agent generator > should match snapshot for BedrockAgentCoreRuntime generated constructs files > agent-Dockerfile 1`] = `
+"FROM public.ecr.aws/docker/library/python:3.12-slim
+
+WORKDIR /app
+
+# Copy bundled package
+COPY --from=workspace dist/apps/test-project/bundle /app
+
+EXPOSE 8080
+
+ENV PYTHONPATH=/app
+
+# Auto-instrument with AWS Distro for OpenTelemetry
+# https://aws-otel.github.io/docs/getting-started/python-sdk/auto-instr
+CMD ["python", "bin/opentelemetry-instrument", "python", "-m", "proj_test_project.snapshot_bedrock_agent.main"]
+"
+`;
+
+exports[`py#strands-agent generator > should match snapshot for BedrockAgentCoreRuntime generated constructs files > agent-construct.ts 1`] = `
+"import { DockerImageAsset, Platform } from 'aws-cdk-lib/aws-ecr-assets';
+import { Construct } from 'constructs';
+import { execSync } from 'child_process';
+import * as path from 'path';
+import * as url from 'url';
+import {
+  AgentCoreRuntime,
+  AgentCoreRuntimeProps,
+} from '../../../core/agent-core/runtime.js';
+
+export type SnapshotBedrockAgentProps = Omit<
+  AgentCoreRuntimeProps,
+  'runtimeName' | 'serverProtocol' | 'containerUri'
+>;
+
+export class SnapshotBedrockAgent extends Construct {
+  public readonly dockerImage: DockerImageAsset;
+  public readonly agentCoreRuntime: AgentCoreRuntime;
+
+  constructor(scope: Construct, id: string, props?: SnapshotBedrockAgentProps) {
+    super(scope, id);
+
+    this.dockerImage = new DockerImageAsset(this, 'DockerImage', {
+      platform: Platform.LINUX_ARM64,
+      directory: path.dirname(url.fileURLToPath(new URL(import.meta.url))),
+      extraHash: execSync(
+        \`docker inspect proj-snapshot-bedrock-agent:latest --format '{{.Descriptor.digest}}'\`,
+        { encoding: 'utf-8' },
+      ).trim(),
+    });
+
+    this.agentCoreRuntime = new AgentCoreRuntime(this, 'AgentCore', {
+      runtimeName: 'SnapshotBedrockAgent',
+      serverProtocol: 'HTTP',
+      containerUri: this.dockerImage.imageUri,
+      ...props,
+    });
+  }
+}
+"
+`;
+
+exports[`py#strands-agent generator > should match snapshot for BedrockAgentCoreRuntime generated constructs files > agent-core-runtime.ts 1`] = `
+"import {
+  Role,
+  ServicePrincipal,
+  PolicyStatement,
+  Effect,
+  PolicyDocument,
+  IGrantable,
+  Grant,
+  IPrincipal,
+} from 'aws-cdk-lib/aws-iam';
+import {
+  AwsCustomResource,
+  AwsCustomResourcePolicy,
+  PhysicalResourceId,
+  PhysicalResourceIdReference,
+} from 'aws-cdk-lib/custom-resources';
+import { Construct } from 'constructs';
+import type { AuthorizerConfiguration } from '@aws-sdk/client-bedrock-agentcore-control';
+import { Stack } from 'aws-cdk-lib';
+
+/**
+ * Options for the AgentCoreRuntime construct
+ */
+export interface AgentCoreRuntimeProps {
+  runtimeName: string;
+  description?: string;
+  containerUri: string;
+  serverProtocol: 'MCP' | 'HTTP';
+  environment?: Record<string, string>;
+  authorizerConfiguration?: AuthorizerConfiguration;
+}
+
+/**
+ * A construct for creating a Bedrock AgentCore Runtime
+ */
+export class AgentCoreRuntime extends Construct implements IGrantable {
+  public readonly role: Role;
+  public readonly arn: string;
+
+  public readonly grantPrincipal: IPrincipal;
+
+  constructor(scope: Construct, id: string, props: AgentCoreRuntimeProps) {
+    super(scope, id);
+
+    const region = Stack.of(this).region;
+    const accountId = Stack.of(this).account;
+
+    this.role = new Role(this, 'AgentCoreRole', {
+      assumedBy: new ServicePrincipal('bedrock-agentcore.amazonaws.com'),
+      inlinePolicies: {
+        AgentCorePolicy: new PolicyDocument({
+          statements: [
+            new PolicyStatement({
+              sid: 'ECRImageAccess',
+              effect: Effect.ALLOW,
+              actions: ['ecr:BatchGetImage', 'ecr:GetDownloadUrlForLayer'],
+              resources: [\`arn:aws:ecr:\${region}:\${accountId}:repository/*\`],
+            }),
+            new PolicyStatement({
+              effect: Effect.ALLOW,
+              actions: ['logs:DescribeLogStreams', 'logs:CreateLogGroup'],
+              resources: [
+                \`arn:aws:logs:\${region}:\${accountId}:log-group:/aws/bedrock-agentcore/runtimes/*\`,
+              ],
+            }),
+            new PolicyStatement({
+              effect: Effect.ALLOW,
+              actions: ['logs:DescribeLogGroups'],
+              resources: [\`arn:aws:logs:\${region}:\${accountId}:log-group:*\`],
+            }),
+            new PolicyStatement({
+              effect: Effect.ALLOW,
+              actions: ['logs:CreateLogStream', 'logs:PutLogEvents'],
+              resources: [
+                \`arn:aws:logs:\${region}:\${accountId}:log-group:/aws/bedrock-agentcore/runtimes/*:log-stream:*\`,
+              ],
+            }),
+            new PolicyStatement({
+              sid: 'ECRTokenAccess',
+              effect: Effect.ALLOW,
+              actions: ['ecr:GetAuthorizationToken'],
+              resources: ['*'],
+            }),
+            new PolicyStatement({
+              effect: Effect.ALLOW,
+              actions: [
+                'xray:PutTraceSegments',
+                'xray:PutTelemetryRecords',
+                'xray:GetSamplingRules',
+                'xray:GetSamplingTargets',
+              ],
+              resources: ['*'],
+            }),
+            new PolicyStatement({
+              effect: Effect.ALLOW,
+              actions: ['cloudwatch:PutMetricData'],
+              resources: ['*'],
+              conditions: {
+                StringEquals: {
+                  'cloudwatch:namespace': 'bedrock-agentcore',
+                },
+              },
+            }),
+            new PolicyStatement({
+              sid: 'GetAgentAccessToken',
+              effect: Effect.ALLOW,
+              actions: [
+                'bedrock-agentcore:GetWorkloadAccessToken',
+                'bedrock-agentcore:GetWorkloadAccessTokenForJWT',
+                'bedrock-agentcore:GetWorkloadAccessTokenForUserId',
+              ],
+              resources: [
+                \`arn:aws:bedrock-agentcore:\${region}:\${accountId}:workload-identity-directory/default\`,
+                \`arn:aws:bedrock-agentcore:\${region}:\${accountId}:workload-identity-directory/default/workload-identity/*\`,
+              ],
+            }),
+            new PolicyStatement({
+              sid: 'BedrockModelInvocation',
+              effect: Effect.ALLOW,
+              actions: [
+                'bedrock:InvokeModel',
+                'bedrock:InvokeModelWithResponseStream',
+              ],
+              resources: [
+                'arn:aws:bedrock:*::foundation-model/*',
+                \`arn:aws:bedrock:\${region}:\${accountId}:*\`,
+              ],
+            }),
+          ],
+        }),
+      },
+    });
+    this.grantPrincipal = this.role.grantPrincipal;
+
+    const agentRuntime = new AwsCustomResource(this, 'MCPSeverRuntime', {
+      onCreate: {
+        service: 'bedrock-agentcore-control',
+        action: 'CreateAgentRuntime',
+        parameters: {
+          agentRuntimeName: props.runtimeName,
+          agentRuntimeArtifact: {
+            containerConfiguration: {
+              containerUri: props.containerUri,
+            },
+          },
+          description: props.description,
+          environmentVariables: props.environment,
+          networkConfiguration: {
+            networkMode: 'PUBLIC',
+          },
+          protocolConfiguration: {
+            serverProtocol: props.serverProtocol,
+          },
+          roleArn: this.role.roleArn,
+          authorizerConfiguration: props.authorizerConfiguration,
+        },
+        physicalResourceId: PhysicalResourceId.fromResponse('agentRuntimeId'),
+      },
+      onUpdate: {
+        service: 'bedrock-agentcore-control',
+        action: 'UpdateAgentRuntime',
+        parameters: {
+          agentRuntimeId: new PhysicalResourceIdReference(),
+          agentRuntimeName: props.runtimeName,
+          agentRuntimeArtifact: {
+            containerConfiguration: {
+              containerUri: props.containerUri,
+            },
+          },
+          description: props.description,
+          environmentVariables: props.environment,
+          networkConfiguration: {
+            networkMode: 'PUBLIC',
+          },
+          protocolConfiguration: {
+            serverProtocol: props.serverProtocol,
+          },
+          roleArn: this.role.roleArn,
+          authorizerConfiguration: props.authorizerConfiguration,
+        },
+        physicalResourceId: PhysicalResourceId.fromResponse('agentRuntimeId'),
+      },
+      onDelete: {
+        service: 'bedrock-agentcore-control',
+        action: 'DeleteAgentRuntime',
+        parameters: {
+          agentRuntimeId: new PhysicalResourceIdReference(),
+        },
+      },
+      policy: AwsCustomResourcePolicy.fromStatements([
+        new PolicyStatement({
+          actions: ['bedrock-agentcore:*'],
+          resources: ['*'],
+        }),
+        new PolicyStatement({
+          actions: ['iam:PassRole'],
+          resources: [this.role.roleArn],
+        }),
+      ]),
+      installLatestAwsSdk: true,
+    });
+
+    this.arn = agentRuntime.getResponseField('agentRuntimeArn');
+  }
+
+  /**
+   * Grant permissions to invoke the agent runtime (if using IAM auth - not required for JWT auth)
+   */
+  public grantInvoke = (grantee: IGrantable) => {
+    Grant.addToPrincipal({
+      grantee,
+      actions: ['bedrock-agentcore:InvokeAgentRuntime'],
+      resourceArns: [this.arn, \`\${this.arn}/*\`],
+    });
+  };
+}
+"
+`;
+
+exports[`py#strands-agent generator > should match snapshot for BedrockAgentCoreRuntime generated constructs files > agents-index.ts 1`] = `
+"export * from './snapshot-bedrock-agent/snapshot-bedrock-agent.js';
+"
+`;
+
+exports[`py#strands-agent generator > should match snapshot for BedrockAgentCoreRuntime generated constructs files > app-index.ts 1`] = `
+"export * from './agents/index.js';
+"
+`;
+
+exports[`py#strands-agent generator > should match snapshot for BedrockAgentCoreRuntime generated constructs files > core-index.ts 1`] = `
+"export * from './app.js';
+export * from './runtime-config.js';
+"
+`;
+
+exports[`py#strands-agent generator > should match snapshot for generated files > strands-agent-__init__.py 1`] = `""`;
+
+exports[`py#strands-agent generator > should match snapshot for generated files > strands-agent-agent.py 1`] = `
+"from contextlib import contextmanager
+
+from strands import Agent, tool
+from strands_tools import current_time
+
+
+# Define a custom tool
+@tool
+def add(a: int, b: int) -> int:
+    return a + b
+
+
+@contextmanager
+def get_agent(session_id: str):
+    yield Agent(
+        system_prompt="""
+You are an addition wizard.
+Use the 'add' tool for addition tasks.
+Refer to tools as your 'spellbook'.
+""",
+        tools=[add, current_time],
+    )
+"
+`;
+
+exports[`py#strands-agent generator > should match snapshot for generated files > strands-agent-main.py 1`] = `
+"from bedrock_agentcore.runtime import BedrockAgentCoreApp
+
+from .agent import get_agent
+
+app = BedrockAgentCoreApp()
+
+
+@app.entrypoint
+async def invoke(payload, context):
+    """Handler for agent invocation"""
+    prompt = payload.get(
+        "prompt", "No prompt found in input, please guide the user "
+        "to create a json payload with prompt key"
+    )
+
+    with get_agent(session_id=context.session_id) as agent:
+        stream = agent.stream_async(prompt)
+        async for event in stream:
+            print(event)
+            yield (event)
+
+
+if __name__ == "__main__":
+    app.run()
+"
+`;
+
+exports[`py#strands-agent generator > should match snapshot for generated files > updated-pyproject.toml 1`] = `
+"[project]
+name = "proj.test_project"
+version = "0.1.0"
+dependencies = [
+  "aws-opentelemetry-distro~=0.11.0",
+  "bedrock-agentcore~=0.1.2",
+  "boto3~=1.40.14",
+  "mcp~=1.13.0",
+  "strands-agents~=1.5.0",
+  "strands-agents-tools~=0.2.4"
+]
+
+[dependency-groups]
+dev = [ ]
+
+[tool.uv]
+dev-dependencies = [ ]
+"
+`;

package/src/py/strands-agent/files/Dockerfile.template

@@ -0,0 +1,14 @@
+FROM public.ecr.aws/docker/library/python:3.12-slim
+
+WORKDIR /app
+
+# Copy bundled package
+COPY --from=workspace <%- distDir %>/bundle /app
+
+EXPOSE 8080
+
+ENV PYTHONPATH=/app
+
+# Auto-instrument with AWS Distro for OpenTelemetry
+# https://aws-otel.github.io/docs/getting-started/python-sdk/auto-instr
+CMD ["python", "bin/opentelemetry-instrument", "python", "-m", "<%- moduleName %>.<%- agentNameSnakeCase %>.main"]

package/src/py/strands-agent/files/agent.py.template

@@ -0,0 +1,22 @@
+from contextlib import contextmanager
+
+from strands import Agent, tool
+from strands_tools import current_time
+
+
+# Define a custom tool
+@tool
+def add(a: int, b: int) -> int:
+    return a + b
+
+
+@contextmanager
+def get_agent(session_id: str):
+    yield Agent(
+        system_prompt="""
+You are an addition wizard.
+Use the 'add' tool for addition tasks.
+Refer to tools as your 'spellbook'.
+""",
+        tools=[add, current_time],
+    )

package/src/py/strands-agent/files/agentcore_mcp_client.py.template

@@ -0,0 +1,99 @@
+import hashlib
+from collections.abc import Generator
+from typing import Any
+
+import httpx
+from botocore.auth import SigV4Auth
+from botocore.awsrequest import AWSRequest
+from mcp.client.streamable_http import streamablehttp_client
+from strands.tools.mcp.mcp_client import MCPClient
+
+
+class SigV4HTTPXAuth(httpx.Auth):
+    """HTTPX Auth class that signs requests with AWS SigV4."""
+
+    def __init__(self, credentials: Any, region: str):
+        self.credentials = credentials
+        self.service = "bedrock-agentcore"
+        self.region = region
+        self.signer = SigV4Auth(credentials, self.service, region)
+
+    def auth_flow(
+        self, request: httpx.Request
+    ) -> Generator[httpx.Request, httpx.Response, None]:
+        headers = dict(request.headers)
+
+        headers.pop("connection", None)
+        headers["x-amz-content-sha256"] = hashlib.sha256(
+            request.content if request.content else b""
+        ).hexdigest()
+
+        aws_request = AWSRequest(
+            method=request.method,
+            url=str(request.url),
+            data=request.content,
+            headers=headers,
+        )
+
+        self.signer.add_auth(aws_request)
+
+        request.headers.clear()
+        request.headers.update(dict(aws_request.headers))
+
+        yield request
+
+
+class AgentCoreMCPClient:
+    """Factory for clients to call MCP servers hosted on Bedrock AgentCore Runtime"""
+
+    @staticmethod
+    def _create(
+        agent_runtime_arn: str,
+        region: str,
+        session_id: str,
+        headers: dict = None,
+        auth_handler: httpx.Auth = None,
+    ):
+        # Build the URL
+        encoded_arn = agent_runtime_arn.replace(":", "%3A").replace("/", "%2F")
+        url = f"https://bedrock-agentcore.{region}.amazonaws.com/runtimes/{encoded_arn}/invocations?qualifier=DEFAULT"
+
+        # Create and return the MCP client
+        return MCPClient(
+            lambda: streamablehttp_client(
+                url,
+                auth=auth_handler,
+                timeout=120,
+                terminate_on_close=False,
+                headers={
+                    "X-Amzn-Bedrock-AgentCore-Runtime-Session-Id": session_id,
+                    **(headers if headers is not None else {}),
+                },
+            )
+        )
+
+    @staticmethod
+    def with_iam_auth(
+        agent_runtime_arn: str, credentials: Any, region: str, session_id: str
+    ) -> MCPClient:
+        """Create an MCP client with IAM (SigV4) authentication."""
+        return AgentCoreMCPClient._create(
+            agent_runtime_arn=agent_runtime_arn,
+            region=region,
+            session_id=session_id,
+            auth_handler=SigV4HTTPXAuth(credentials, region),
+        )
+
+    @staticmethod
+    def with_jwt_auth(
+        agent_runtime_arn: str, access_token: str, region: str, session_id: str
+    ) -> MCPClient:
+        """Create an MCP client with JWT authentication."""
+        return AgentCoreMCPClient._create(
+            agent_runtime_arn=agent_runtime_arn,
+            region=region,
+            session_id=session_id,
+            headers={
+                "Authorization": f"Bearer {access_token}",
+            },
+        )

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

@@ -0,0 +1,24 @@
+from bedrock_agentcore.runtime import BedrockAgentCoreApp
+
+from .agent import get_agent
+
+app = BedrockAgentCoreApp()
+
+
+@app.entrypoint
+async def invoke(payload, context):
+    """Handler for agent invocation"""
+    prompt = payload.get(
+        "prompt", "No prompt found in input, please guide the user "
+        "to create a json payload with prompt key"
+    )
+
+    with get_agent(session_id=context.session_id) as agent:
+        stream = agent.stream_async(prompt)
+        async for event in stream:
+            print(event)
+            yield (event)
+
+
+if __name__ == "__main__":
+    app.run()

package/src/py/strands-agent/generator.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { GeneratorCallback, Tree } from '@nx/devkit';
+import { PyStrandsAgentGeneratorSchema } from './schema';
+import { NxGeneratorInfo } from '../../utils/nx';
+export declare const PY_STRANDS_AGENT_GENERATOR_INFO: NxGeneratorInfo;
+export declare const pyStrandsAgentGenerator: (tree: Tree, options: PyStrandsAgentGeneratorSchema) => Promise<GeneratorCallback>;
+export default pyStrandsAgentGenerator;

package/src/py/strands-agent/generator.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pyStrandsAgentGenerator = exports.PY_STRANDS_AGENT_GENERATOR_INFO = void 0;
+const tslib_1 = require("tslib");
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const devkit_1 = require("@nx/devkit");
+const nx_1 = require("../../utils/nx");
+const metrics_1 = require("../../utils/metrics");
+const format_1 = require("../../utils/format");
+const names_1 = require("../../utils/names");
+const py_1 = require("../../utils/py");
+const agent_core_constructs_1 = require("../../utils/agent-core-constructs/agent-core-constructs");
+const bundle_1 = require("../../utils/bundle");
+const npm_scope_1 = require("../../utils/npm-scope");
+const shared_constructs_1 = require("../../utils/shared-constructs");
+const shared_constructs_constants_1 = require("../../utils/shared-constructs-constants");
+const logger_1 = require("@nxlv/python/src/executors/utils/logger");
+const provider_1 = require("@nxlv/python/src/provider/uv/provider");
+exports.PY_STRANDS_AGENT_GENERATOR_INFO = (0, nx_1.getGeneratorInfo)(__filename);
+const pyStrandsAgentGenerator = (tree, options) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const project = (0, nx_1.readProjectConfigurationUnqualified)(tree, options.project);
+    const pyProjectPath = (0, devkit_1.joinPathFragments)(project.root, 'pyproject.toml');
+    // Check if the project has a pyproject.toml file
+    if (!pyProjectPath) {
+        throw new Error(`Unsupported project ${options.project}. Expected a Python project (with a pyproject.toml)`);
+    }
+    if (!project.sourceRoot) {
+        throw new Error(`This project does not have a source root. Please add a source root to the project configuration before running this generator.`);
+    }
+    // Module name is the last part of the source root,
+    const sourceParts = project.sourceRoot.split('/');
+    const moduleName = sourceParts[sourceParts.length - 1];
+    const name = (0, names_1.kebabCase)((_a = options.name) !== null && _a !== void 0 ? _a : `${(0, names_1.kebabCase)(project.name.split('.').pop())}-agent`);
+    const agentNameSnakeCase = (0, names_1.toSnakeCase)((_b = options.name) !== null && _b !== void 0 ? _b : 'agent');
+    const agentNameClassName = (0, names_1.toClassName)(name);
+    const targetSourceDir = (0, devkit_1.joinPathFragments)(project.sourceRoot, agentNameSnakeCase);
+    const distDir = (0, devkit_1.joinPathFragments)('dist', project.root);
+    const computeType = (_c = options.computeType) !== null && _c !== void 0 ? _c : 'BedrockAgentCoreRuntime';
+    // Generate example agent
+    (0, devkit_1.generateFiles)(tree, (0, devkit_1.joinPathFragments)(__dirname, 'files'), targetSourceDir, {
+        name,
+        agentNameSnakeCase,
+        agentNameClassName,
+        moduleName,
+        distDir,
+    }, { overwriteStrategy: devkit_1.OverwriteStrategy.KeepExisting });
+    (0, py_1.addDependenciesToPyProjectToml)(tree, project.root, [
+        'aws-opentelemetry-distro',
+        'bedrock-agentcore',
+        'boto3',
+        'mcp',
+        'strands-agents',
+        'strands-agents-tools',
+    ]);
+    if (computeType === 'BedrockAgentCoreRuntime') {
+        const dockerImageTag = `${(0, npm_scope_1.getNpmScope)(tree)}-${name}:latest`;
+        // Add bundle target
+        (0, bundle_1.addPythonBundleTarget)(project, {
+            pythonPlatform: 'aarch64-manylinux2014',
+        });
+        const dockerTargetName = `${name}-docker`;
+        // Add a docker target specific to this MCP server
+        project.targets[dockerTargetName] = {
+            cache: true,
+            executor: 'nx:run-commands',
+            options: {
+                commands: [
+                    `docker build --platform linux/arm64 -t ${dockerImageTag} ${targetSourceDir} --build-context workspace=.`,
+                ],
+                parallel: false,
+            },
+            dependsOn: ['bundle'],
+        };
+        project.targets.docker = Object.assign(Object.assign({}, project.targets.docker), { dependsOn: [
+                ...((_e = (_d = project.targets.docker) === null || _d === void 0 ? void 0 : _d.dependsOn) !== null && _e !== void 0 ? _e : []).filter((t) => t !== dockerTargetName),
+                dockerTargetName,
+            ] });
+        project.targets.build = Object.assign(Object.assign({}, project.targets.build), { dependsOn: [
+                ...((_g = (_f = project.targets.build) === null || _f === void 0 ? void 0 : _f.dependsOn) !== null && _g !== void 0 ? _g : []).filter((t) => t !== 'docker'),
+                'docker',
+            ] });
+        // Add shared constructs
+        yield (0, shared_constructs_1.sharedConstructsGenerator)(tree);
+        // Ensure common constructs builds after our agent project
+        (0, devkit_1.updateJson)(tree, (0, devkit_1.joinPathFragments)(shared_constructs_constants_1.PACKAGES_DIR, shared_constructs_constants_1.SHARED_CONSTRUCTS_DIR, 'project.json'), (config) => {
+            var _a;
+            if (!config.targets) {
+                config.targets = {};
+            }
+            if (!config.targets.build) {
+                config.targets.build = {};
+            }
+            config.targets.build.dependsOn = [
+                ...((_a = config.targets.build.dependsOn) !== null && _a !== void 0 ? _a : []).filter((t) => t !== `${project.name}:build`),
+                `${project.name}:build`,
+            ];
+            return config;
+        });
+        // Add the construct to deploy the agent
+        (0, agent_core_constructs_1.addAgentConstruct)(tree, {
+            agentNameKebabCase: name,
+            agentNameClassName,
+            dockerImageTag,
+        });
+    }
+    else {
+        // No Dockerfile needed for non-hosted Agent
+        tree.delete((0, devkit_1.joinPathFragments)(targetSourceDir, 'Dockerfile'));
+    }
+    (0, devkit_1.updateProjectConfiguration)(tree, project.name, Object.assign(Object.assign({}, project), { targets: Object.assign(Object.assign({}, project.targets), { 
+            // TODO: Add hot-reload
+            [`${options.name ? name : 'agent'}-serve`]: {
+                executor: 'nx:run-commands',
+                options: {
+                    commands: [
+                        `uv run python -m ${moduleName}.${agentNameSnakeCase}.main`,
+                    ],
+                    cwd: '{projectRoot}',
+                },
+                continuous: true,
+            } }) }));
+    yield (0, metrics_1.addGeneratorMetricsIfApplicable)(tree, [
+        exports.PY_STRANDS_AGENT_GENERATOR_INFO,
+    ]);
+    yield (0, format_1.formatFilesInSubtree)(tree);
+    return () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        (0, devkit_1.installPackagesTask)(tree);
+        yield new provider_1.UVProvider(tree.root, new logger_1.Logger(), tree).install();
+    });
+});
+exports.pyStrandsAgentGenerator = pyStrandsAgentGenerator;
+exports.default = exports.pyStrandsAgentGenerator;
+//# sourceMappingURL=generator.js.map