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

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

@@ -0,0 +1,231 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`py#agent#a2a-connection generator > should match snapshot for agent-connection core files > agentcore_a2a_client_config.py 1`] = `
+"from collections.abc import Callable
+
+import boto3
+import httpx
+from a2a.client import ClientConfig
+
+from .agentcore_endpoints import a2a_url_from_arn, region_from_arn
+from .auth.session import jwt_auth, plain_auth, sigv4_auth
+
+
+def _config(url: str, auth: httpx.Auth) -> tuple[str, ClientConfig]:
+    httpx_client = httpx.AsyncClient(auth=auth, timeout=120)
+    return url, ClientConfig(httpx_client=httpx_client, streaming=False)
+
+
+class AgentCoreA2aClientConfig:
+    """Factory for A2A client configs that connect to a Bedrock AgentCore
+    runtime. Each forwards the current async-context session via the AgentCore
+    session header. Framework-agnostic — wrap the result in a framework's
+    A2A client."""
+
+    @staticmethod
+    def with_iam_auth(agent_runtime_arn: str) -> tuple[str, ClientConfig]:
+        """SigV4-authenticated A2A client config for a Bedrock AgentCore runtime."""
+        region = region_from_arn(agent_runtime_arn)
+        credentials = boto3.Session(region_name=region).get_credentials()
+        return _config(a2a_url_from_arn(agent_runtime_arn), sigv4_auth(credentials, region))
+
+    @staticmethod
+    def with_jwt_auth(agent_runtime_arn: str, access_token_provider: Callable[[], str]) -> tuple[str, ClientConfig]:
+        """Bearer-authenticated A2A client config for a Bedrock AgentCore runtime."""
+        return _config(a2a_url_from_arn(agent_runtime_arn), jwt_auth(access_token_provider))
+
+    @staticmethod
+    def without_auth(url: str) -> tuple[str, ClientConfig]:
+        """Plain-HTTP A2A client config — for local dev."""
+        return _config(url, plain_auth())
+"
+`;
+
+exports[`py#agent#a2a-connection generator > should match snapshot for agent-connection core files > agentcore_a2a_client_strands.py 1`] = `
+"import asyncio
+from collections.abc import Callable
+from concurrent.futures import ThreadPoolExecutor
+
+import httpx
+from a2a.client import ClientConfig
+from strands.agent.a2a_agent import A2AAgent
+from strands.agent.agent_result import AgentResult
+
+from .agentcore_a2a_client_config import AgentCoreA2aClientConfig
+
+
+def _run_sync(coro):
+    # The tool is invoked from sync agent code, which under uvicorn runs inside a
+    # live event loop where asyncio.run() would raise — fall back to a worker.
+    try:
+        asyncio.get_running_loop()
+    except RuntimeError:
+        return asyncio.run(coro)
+    with ThreadPoolExecutor(max_workers=1) as pool:
+        return pool.submit(asyncio.run, coro).result()
+
+
+class _A2AClient:
+    def __init__(
+        self,
+        url: str,
+        client_config: ClientConfig,
+        *,
+        name: str | None,
+        description: str | None,
+    ):
+        shared_client = client_config.httpx_client
+        if shared_client is None:
+            raise RuntimeError("A2A client config is missing an httpx client")
+        self._url = url
+        self._auth = shared_client.auth
+        self._timeout = shared_client.timeout
+        self._name = name
+        self._description = description
+
+    def __call__(self, prompt: str) -> AgentResult:
+        return _run_sync(self._invoke(prompt))
+
+    async def _invoke(self, prompt: str) -> AgentResult:
+        async with httpx.AsyncClient(auth=self._auth, timeout=self._timeout) as httpx_client:
+            agent = A2AAgent(
+                endpoint=self._url,
+                name=self._name,
+                description=self._description,
+                client_config=ClientConfig(httpx_client=httpx_client, streaming=False),
+            )
+            return await agent.invoke_async(prompt)
+
+
+def _build(config: tuple, *, name: str | None, description: str | None) -> _A2AClient:
+    url, client_config = config
+    return _A2AClient(url, client_config, name=name, description=description)
+
+
+class AgentCoreA2aClientStrands:
+    """Factory for Strands A2A clients that connect to an AgentCore runtime."""
+
+    @staticmethod
+    def with_iam_auth(
+        agent_runtime_arn: str,
+        *,
+        name: str | None = None,
+        description: str | None = None,
+    ) -> _A2AClient:
+        """SigV4-authenticated client for a Bedrock AgentCore runtime."""
+        return _build(
+            AgentCoreA2aClientConfig.with_iam_auth(agent_runtime_arn),
+            name=name,
+            description=description,
+        )
+
+    @staticmethod
+    def with_jwt_auth(
+        agent_runtime_arn: str,
+        access_token_provider: Callable[[], str],
+        *,
+        name: str | None = None,
+        description: str | None = None,
+    ) -> _A2AClient:
+        """Bearer-authenticated client for a Bedrock AgentCore runtime."""
+        return _build(
+            AgentCoreA2aClientConfig.with_jwt_auth(agent_runtime_arn, access_token_provider),
+            name=name,
+            description=description,
+        )
+
+    @staticmethod
+    def without_auth(
+        url: str,
+        *,
+        name: str | None = None,
+        description: str | None = None,
+    ) -> _A2AClient:
+        """Plain-HTTP client — for local dev."""
+        return _build(
+            AgentCoreA2aClientConfig.without_auth(url),
+            name=name,
+            description=description,
+        )
+"
+`;
+
+exports[`py#agent#a2a-connection generator > should match snapshot for agent-connection core files > remote_client_strands.py 1`] = `
+"import os
+
+from test_agent_connection.core.agentcore_a2a_client_strands import (
+    AgentCoreA2aClientStrands,
+)
+from test_agent_connection.core.runtime_config import (
+    get_agentcore_runtime_config,
+)
+
+
+class RemoteClientStrands:
+    """Strands client for the Remote A2A agent."""
+
+    @staticmethod
+    def create():
+        if os.environ.get("LOCAL_DEV") == "true":
+            return AgentCoreA2aClientStrands.without_auth("http://localhost:9001/")
+        config = get_agentcore_runtime_config()
+        agent_runtime = config.get("agentRuntimes", {}).get("Remote")
+        agent_runtime_arn = agent_runtime.get("arn") if agent_runtime else None
+        if not agent_runtime_arn:
+            raise RuntimeError("No connected agent runtime named 'Remote' found in runtime configuration.")
+        return AgentCoreA2aClientStrands.with_iam_auth(agent_runtime_arn)
+"
+`;
+
+exports[`py#agent#a2a-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/a2a-connection/files/agent-connection/app/__targetAgentSnakeCase___client_strands.py.template

@@ -0,0 +1,29 @@
+import os
+
+from <%- agentConnectionModuleName %>.core.agentcore_a2a_client_strands import (
+    AgentCoreA2aClientStrands,
+)
+from <%- agentConnectionModuleName %>.core.runtime_config import (
+    get_agentcore_runtime_config,
+)
+
+
+class <%- targetAgentClassName %>ClientStrands:
+    """Strands client for the <%- targetAgentClassName %> A2A agent."""
+
+    @staticmethod
+    def create():
+        if os.environ.get("LOCAL_DEV") == "true":
+            return AgentCoreA2aClientStrands.without_auth(
+                "http://localhost:<%- targetAgentPort %>/"
+            )
+        config = get_agentcore_runtime_config()
+        agent_runtime = config.get("agentRuntimes", {}).get(
+            "<%- targetAgentClassName %>"
+        )
+        agent_runtime_arn = agent_runtime.get("arn") if agent_runtime else None
+        if not agent_runtime_arn:
+            raise RuntimeError(
+                "No connected agent runtime named '<%- targetAgentClassName %>' found in runtime configuration."
+            )
+        return AgentCoreA2aClientStrands.with_iam_auth(agent_runtime_arn)

package/src/py/agent/a2a-connection/files/langchain/agent-connection/app/__targetAgentSnakeCase___client_langchain.py.template

@@ -0,0 +1,29 @@
+import os
+
+from <%- agentConnectionModuleName %>.core.agentcore_a2a_client_langchain import (
+    AgentCoreA2aClientLangChain,
+)
+from <%- agentConnectionModuleName %>.core.runtime_config import (
+    get_agentcore_runtime_config,
+)
+
+
+class <%- targetAgentClassName %>ClientLangChain:
+    """LangChain client for the <%- targetAgentClassName %> A2A agent."""
+
+    @staticmethod
+    def create():
+        if os.environ.get("LOCAL_DEV") == "true":
+            return AgentCoreA2aClientLangChain.without_auth(
+                "http://localhost:<%- targetAgentPort %>/"
+            )
+        config = get_agentcore_runtime_config()
+        agent_runtime = config.get("agentRuntimes", {}).get(
+            "<%- targetAgentClassName %>"
+        )
+        agent_runtime_arn = agent_runtime.get("arn") if agent_runtime else None
+        if not agent_runtime_arn:
+            raise RuntimeError(
+                "No connected agent runtime named '<%- targetAgentClassName %>' found in runtime configuration."
+            )
+        return AgentCoreA2aClientLangChain.with_iam_auth(agent_runtime_arn)

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

@@ -3,8 +3,32 @@
  * 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 { PyAgentA2aConnectionGeneratorSchema } from './schema';
+/** The metadata this generator records, which its predicates read. */
+export interface PyAgentA2aConnectionMetadata {
+    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", PyAgentA2aConnectionMetadata>[], readonly [{
+    readonly name: "boto3";
+}, {
+    readonly name: "httpx";
+}, {
+    readonly name: "strands-agents[a2a]";
+    readonly when: (m: PyAgentA2aConnectionMetadata) => boolean;
+}, {
+    readonly name: "a2a-sdk";
+    readonly when: (m: PyAgentA2aConnectionMetadata) => boolean;
+}, {
+    readonly name: "aws-lambda-powertools";
+} & {
+    versionOnly: true;
+}, {
+    readonly name: "strands-agents";
+} & {
+    versionOnly: true;
+}]>;
 export declare const PY_AGENT_A2A_CONNECTION_GENERATOR_INFO: NxGeneratorInfo;
 export declare const pyAgentA2aConnectionGenerator: (tree: Tree, options: PyAgentA2aConnectionGeneratorSchema) => Promise<GeneratorCallback>;
 export default pyAgentA2aConnectionGenerator;

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

@@ -1,24 +1,53 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.pyAgentA2aConnectionGenerator = exports.PY_AGENT_A2A_CONNECTION_GENERATOR_INFO = void 0;
 /**
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
- */
-const devkit_1 = require("@nx/devkit");
-const agent_connection_1 = require("../../../utils/agent-connection/agent-connection");
-const ast_1 = require("../../../utils/ast");
-const format_1 = require("../../../utils/format");
-const metrics_1 = require("../../../utils/metrics");
-const names_1 = require("../../../utils/names");
-const nx_1 = require("../../../utils/nx");
-const py_1 = require("../../../utils/py");
-/** Prefix a GritQL pattern with `language python` */
-const py = (pattern) => `language python\n${pattern}`;
-exports.PY_AGENT_A2A_CONNECTION_GENERATOR_INFO = (0, nx_1.getGeneratorInfo)(__filename);
-const pyAgentA2aConnectionGenerator = async (tree, options) => {
-    const sourceProject = (0, nx_1.readProjectConfigurationUnqualified)(tree, options.sourceProject);
-    const targetProject = (0, nx_1.readProjectConfigurationUnqualified)(tree, options.targetProject);
+ */ import { generateFiles, joinPathFragments, OverwriteStrategy, updateProjectConfiguration } from "@nx/devkit";
+import { addPyDependencies } from "../../../utils/add-dependencies.js";
+import { AGENT_CONNECTION_PY_DEPENDENCIES, addPythonCoreClient, addPythonReExport, ensurePythonAgentConnectionProject, getPythonAgentConnectionModuleName, getPythonAgentConnectionProject, getPythonAgentConnectionProjectDir, PY_CLIENT_NAMING, resolveAgentFramework } from "../../../utils/agent-connection/agent-connection.js";
+import { addPythonDestructuredImport, applyGritQL, matchGritQL } 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";
+/** Prefix a GritQL pattern with `language python` */ const py = (pattern)=>`language python\n${pattern}`;
+/** The module each framework imports the `tool` decorator from. */ const TOOL_IMPORT_MODULE = {
+    strands: 'strands',
+    langchain: 'langchain_core.tools'
+};
+/** The GritQL pattern matching each framework's agent constructor. */ const AGENT_CONSTRUCTOR = {
+    strands: 'yield Agent($_)',
+    langchain: 'create_agent($_)'
+};
+// Each framework's Layer-2 client needs its own A2A transport: Strands wraps
+// strands' `A2AAgent` (strands-agents[a2a]); LangChain drives the a2a SDK
+// directly (a2a-sdk) and must not pull Strands in.
+export const DEPENDENCIES = declareDependencies()({
+    py: [
+        {
+            name: 'boto3'
+        },
+        {
+            name: 'httpx'
+        },
+        {
+            name: 'strands-agents[a2a]',
+            when: (m)=>m.framework === 'strands'
+        },
+        {
+            name: 'a2a-sdk',
+            when: (m)=>m.framework === 'langchain'
+        },
+        ...ownedElsewhere(AGENT_CONNECTION_PY_DEPENDENCIES)
+    ]
+});
+export const PY_AGENT_A2A_CONNECTION_GENERATOR_INFO = getGeneratorInfo(import.meta.filename);
+export const pyAgentA2aConnectionGenerator = async (tree, options)=>{
+    const sourceProject = readProjectConfigurationUnqualified(tree, options.sourceProject);
+    const targetProject = readProjectConfigurationUnqualified(tree, options.targetProject);
     const agentComponent = options.sourceComponent;
     const targetAgentComponent = options.targetComponent;
     if (!agentComponent || !targetAgentComponent) {
@@ -27,95 +56,122 @@ const pyAgentA2aConnectionGenerator = async (tree, options) => {
     if ((targetAgentComponent.protocol ?? '').toLowerCase() !== 'a2a') {
         throw new Error(`Target agent '${targetAgentComponent.name}' uses the ${targetAgentComponent.protocol ?? 'http'} protocol — only A2A agents can be connected as tools.`);
     }
-    if (targetAgentComponent.auth &&
-        targetAgentComponent.auth.toLowerCase() !== 'iam') {
+    if (targetAgentComponent.auth && targetAgentComponent.auth.toLowerCase() !== 'iam') {
         throw new Error(`A2A agent connection currently only supports IAM authentication, but '${targetAgentComponent.name}' uses '${targetAgentComponent.auth}' authentication.`);
     }
     const targetAgentComponentName = targetAgentComponent.name ?? 'agent';
     const targetAgentClassName = targetAgentComponent.rc;
-    const targetAgentSnakeCase = (0, names_1.snakeCase)(targetAgentClassName);
+    const targetAgentSnakeCase = snakeCase(targetAgentClassName);
     const targetAgentPort = targetAgentComponent.port ?? 9000;
+    // The source agent's framework drives everything that varies: the client
+    // naming + app template (shared with the mcp/gateway generators via
+    // PY_CLIENT_NAMING), the A2A transport dep (see DEPENDENCIES), and the
+    // agent.py transform below. Each framework wraps its own A2A Layer-2 client
+    // (Strands' A2AAgent vs an a2a-sdk-only client) over the shared,
+    // framework-agnostic A2A client config. Keyed on the framework, not a
+    // boolean, so a third framework stays additive.
+    const framework = resolveAgentFramework(agentComponent.framework);
+    const naming = PY_CLIENT_NAMING[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
+    };
     // 1. Ensure the shared Python agent-connection project exists + has the
-    //    A2A core client and its shared SigV4 auth helper.
-    await (0, agent_connection_1.ensurePythonAgentConnectionProject)(tree);
-    (0, agent_connection_1.addPythonCoreClient)(tree, 'auth');
-    (0, agent_connection_1.addPythonCoreClient)(tree, 'a2a');
-    const agentConnectionProjectDir = (0, agent_connection_1.getPythonAgentConnectionProjectDir)(tree);
-    const agentConnectionModuleName = (0, agent_connection_1.getPythonAgentConnectionModuleName)(tree);
-    const agentConnectionPackageName = (0, agent_connection_1.getPythonAgentConnectionPackageName)(tree);
-    // Python deps required by the A2A core client + shared auth helper.
-    (0, py_1.addDependenciesToPyProjectToml)(tree, agentConnectionProjectDir, [
-        'boto3',
-        'httpx',
-        'strands-agents[a2a]',
-    ]);
+    //    A2A core client (framework Layer-2) and its shared SigV4 auth helper.
+    await ensurePythonAgentConnectionProject(tree, DEPENDENCIES);
+    await addPythonCoreClient(tree, 'a2a', DEPENDENCIES, framework);
+    const agentConnectionProjectDir = getPythonAgentConnectionProjectDir(tree);
+    const agentConnectionModuleName = getPythonAgentConnectionModuleName(tree);
+    // A2A client config + shared auth helper deps, plus the framework's A2A
+    // transport dep. These belong to the shared agent-connection project, which
+    // holds the client.
+    addPyDependencies(tree, DEPENDENCIES, {
+        metadata,
+        projectRoot: agentConnectionProjectDir
+    });
     // 2. Generate the per-connection client into the shared agent-connection project
-    const appDir = (0, devkit_1.joinPathFragments)(agentConnectionProjectDir, agentConnectionModuleName, 'app');
-    (0, devkit_1.generateFiles)(tree, (0, devkit_1.joinPathFragments)(__dirname, 'files', 'agent-connection', 'app'), appDir, {
+    const appDir = joinPathFragments(agentConnectionProjectDir, agentConnectionModuleName, 'app');
+    generateFiles(tree, joinPathFragments(import.meta.dirname, 'files', naming.appTemplateSubdir), appDir, {
         targetAgentSnakeCase,
         targetAgentClassName,
         targetAgentPort,
-        agentConnectionModuleName,
-    }, { overwriteStrategy: devkit_1.OverwriteStrategy.KeepExisting });
+        agentConnectionModuleName
+    }, {
+        overwriteStrategy: OverwriteStrategy.KeepExisting
+    });
     // Ensure app/__init__.py exists
-    const appInitPath = (0, devkit_1.joinPathFragments)(appDir, '__init__.py');
+    const appInitPath = joinPathFragments(appDir, '__init__.py');
     if (!tree.exists(appInitPath)) {
         tree.write(appInitPath, '');
     }
     // Add re-export to module __init__.py
-    const moduleInitPath = (0, devkit_1.joinPathFragments)(agentConnectionProjectDir, agentConnectionModuleName, '__init__.py');
-    await (0, agent_connection_1.addPythonReExport)(tree, moduleInitPath, `.app.${targetAgentSnakeCase}_client`, `${targetAgentClassName}Client`);
+    const moduleInitPath = joinPathFragments(agentConnectionProjectDir, agentConnectionModuleName, '__init__.py');
+    await addPythonReExport(tree, moduleInitPath, `.app.${targetAgentSnakeCase}_client_${naming.clientModuleSuffix}`, `${targetAgentClassName}Client${naming.clientClassSuffix}`);
     // 3. Transform agent.py to add the A2A client import + wrap it as a tool
-    const agentSourceDir = (0, devkit_1.joinPathFragments)(sourceProject.root, agentComponent.path ?? 'src');
-    const agentFilePath = (0, devkit_1.joinPathFragments)(agentSourceDir, 'agent.py');
+    const agentSourceDir = joinPathFragments(sourceProject.root, agentComponent.path ?? 'src');
+    const agentFilePath = joinPathFragments(agentSourceDir, 'agent.py');
     if (tree.exists(agentFilePath)) {
-        const clientClassName = `${targetAgentClassName}Client`;
+        const clientClassName = `${targetAgentClassName}Client${naming.clientClassSuffix}`;
         const clientVarName = targetAgentSnakeCase;
         const toolName = `ask_${targetAgentSnakeCase}`;
-        await addImportToAgentFile(tree, agentFilePath, agentConnectionModuleName, clientClassName);
-        await addToolToAgent(tree, agentFilePath, toolName);
-        await addClientToolToGetAgent(tree, agentFilePath, clientClassName, clientVarName, toolName, targetAgentClassName);
+        await addImportToAgentFile(tree, agentFilePath, agentConnectionModuleName, clientClassName, framework);
+        await addToolToAgent(tree, agentFilePath, toolName, framework);
+        await addClientToolToGetAgent(tree, agentFilePath, clientClassName, clientVarName, toolName, targetAgentClassName, framework);
     }
     // 4. Add workspace dependency from agent project to agent-connection project
-    (0, py_1.addWorkspaceDependencyToPyProject)(tree, sourceProject.root, agentConnectionPackageName);
-    // 5. Set up serve-local target dependencies — chain onto the target agent
+    addWorkspaceDependencyToPyProject(tree, sourceProject, getPythonAgentConnectionProject(tree));
+    // 5. Set up dev target dependencies — chain onto the target agent
     const agentName = agentComponent.name ?? 'agent';
-    const serveLocalTargetName = `${agentName}-serve-local`;
-    const targetServeLocalTargetName = `${targetAgentComponentName}-serve-local`;
-    if (sourceProject.targets?.[serveLocalTargetName]) {
-        (0, nx_1.addDependencyToTargetIfNotPresent)(sourceProject, serveLocalTargetName, {
-            projects: [targetProject.name],
-            target: targetServeLocalTargetName,
+    const devTargetName = `${agentName}-dev`;
+    const targetDevTargetName = `${targetAgentComponentName}-dev`;
+    if (sourceProject.targets?.[devTargetName]) {
+        addDependencyToTargetIfNotPresent(sourceProject, devTargetName, {
+            projects: [
+                targetProject.name
+            ],
+            target: targetDevTargetName
         });
-        (0, devkit_1.updateProjectConfiguration)(tree, sourceProject.name, sourceProject);
+        updateProjectConfiguration(tree, sourceProject.name, sourceProject);
     }
-    await (0, metrics_1.addGeneratorMetricsIfApplicable)(tree, [
-        exports.PY_AGENT_A2A_CONNECTION_GENERATOR_INFO,
+    // Recorded so the version sync knows this connection's dependencies are ours.
+    addComponentGeneratorMetadata(tree, sourceProject.name, PY_AGENT_A2A_CONNECTION_GENERATOR_INFO, toProjectRelativePath(sourceProject, agentFilePath), targetAgentClassName, // `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_A2A_CONNECTION_GENERATOR_INFO
     ]);
-    await (0, format_1.formatFilesInSubtree)(tree);
-    return () => {
-        (0, devkit_1.installPackagesTask)(tree);
-    };
+    await formatFilesInSubtree(tree);
+    return ()=>installDependencies(tree, options.preferInstallDependencies, {
+            languages: [
+                'typescript'
+            ]
+        });
 };
-exports.pyAgentA2aConnectionGenerator = pyAgentA2aConnectionGenerator;
 /**
  * Add imports to agent.py:
- *  - `tool` from `strands`
+ *  - `tool` (from `strands`, or `langchain_core.tools` for LangChain agents)
  *  - the per-connection client class from the shared agent-connection module
- */
-const addImportToAgentFile = async (tree, filePath, agentConnectionModuleName, clientClassName) => {
-    await (0, ast_1.addPythonDestructuredImport)(tree, filePath, ['tool'], 'strands');
-    await (0, ast_1.addPythonDestructuredImport)(tree, filePath, [clientClassName], agentConnectionModuleName);
+ */ const addImportToAgentFile = async (tree, filePath, agentConnectionModuleName, clientClassName, framework)=>{
+    await addPythonDestructuredImport(tree, filePath, [
+        'tool'
+    ], TOOL_IMPORT_MODULE[framework]);
+    await addPythonDestructuredImport(tree, filePath, [
+        clientClassName
+    ], agentConnectionModuleName);
 };
 /**
  * Add the A2A tool to the Agent's tools array using GritQL.
  *
- * Scoped via `$old <: within \`yield Agent($_)\`` so unrelated `tools=`
- * keyword arguments elsewhere in the file are not touched.
- */
-const addToolToAgent = async (tree, filePath, toolName) => {
-    await (0, ast_1.applyGritQL)(tree, filePath, py(`\`tools=$old\` where {
-  $old <: within \`yield Agent($_)\`,
+ * Scoped to the framework's agent constructor so unrelated `tools=` keyword
+ * arguments elsewhere in the file are not touched.
+ */ const addToolToAgent = async (tree, filePath, toolName, framework)=>{
+    const scope = AGENT_CONSTRUCTOR[framework];
+    await applyGritQL(tree, filePath, py(`\`tools=$old\` where {
+  $old <: within \`${scope}\`,
   $old <: not contains \`${toolName}\`,
   if ($old <: \`[]\`) {
     $old => \`[${toolName}]\`
@@ -126,19 +182,18 @@ const addToolToAgent = async (tree, filePath, toolName) => {
 };
 /**
  * Wrap the get_agent body so the remote A2A client is created and exposed
- * as a `@tool`-decorated closure before yielding the Agent.
+ * as a `@tool`-decorated closure before constructing the Agent.
  *
  * Unlike MCP clients, A2A clients aren't context managers — we don't need
  * a `with` block around them. Creation + tool definition happen at the
- * top of the function body.
- */
-const addClientToolToGetAgent = async (tree, filePath, clientClassName, clientVarName, toolName, targetAgentClassName) => {
-    if (await (0, ast_1.matchGritQL)(tree, filePath, `\`${clientClassName}.create\``)) {
+ * top of the function body, anchored on the framework's agent constructor.
+ */ const addClientToolToGetAgent = async (tree, filePath, clientClassName, clientVarName, toolName, targetAgentClassName, framework)=>{
+    if (await matchGritQL(tree, filePath, py(`\`${clientClassName}.create\``))) {
         return;
     }
-    // The tool function we'll insert. Strands tools in Python are just
-    // @tool-decorated callables, so we define them inline in get_agent.
-    // A2AAgent is directly callable (syncs over invoke_async internally).
+    // Both frameworks' tools are @tool-decorated callables (the decorator's
+    // import differs, handled in addImportToAgentFile), defined inline in
+    // get_agent. The client is directly callable, returning the remote's reply.
     const toolBlock = `${clientVarName} = ${clientClassName}.create()
 
     @tool
@@ -146,16 +201,18 @@ const addClientToolToGetAgent = async (tree, filePath, clientClassName, clientVa
         """Delegate a question to the remote ${targetAgentClassName} A2A agent and return its reply."""
         return str(${clientVarName}(prompt))
 `;
-    // Prepend client creation + tool definition to the function body.
-    // This works whether or not a prior MCP `with` block is present since we
-    // insert before any existing statements.
-    await (0, ast_1.applyGritQL)(tree, filePath, py(`\`def get_agent($params):
+    // Prepend client creation + tool definition to the function body, anchored on
+    // the framework's agent constructor. This works whether or not a prior MCP
+    // block is present since we insert before any existing statements.
+    const anchor = AGENT_CONSTRUCTOR[framework];
+    await applyGritQL(tree, filePath, py(`\`def get_agent($params):
     $body\` where {
-  $body <: contains \`yield Agent($_)\`,
+  $body <: contains \`${anchor}\`,
   $body <: not contains \`${clientClassName}.create\`
 } => \`def get_agent($params):
     ${toolBlock}
     $body\``));
 };
-exports.default = exports.pyAgentA2aConnectionGenerator;
+export default pyAgentA2aConnectionGenerator;
+
 //# sourceMappingURL=generator.js.map