Agent TypeScript Strands vers Agent A2A

Le générateur connection peut connecter votre Agent Strands TypeScript à un agent A2A distant — soit TypeScript ou Python — afin que votre agent puisse déléguer à un autre agent en tant qu’outil.

Le générateur configure tout le câblage nécessaire pour que votre agent puisse découvrir et invoquer l’agent A2A distant, à la fois lorsqu’il est déployé sur AWS (via Bedrock AgentCore) et lors de l’exécution locale.

Prérequis

Avant d’utiliser ce générateur, assurez-vous d’avoir :

Un projet TypeScript avec un composant Agent (n’importe quel protocole)
Un projet avec un composant Agent généré avec --protocol=A2A et --auth=IAM (soit ts#agent ou py#agent)
Les deux composants créés avec infra: agentcore

Utilisation

Installez le Nx Console VSCode Plugin si ce n'est pas déjà fait
Ouvrez la console Nx dans VSCode
Cliquez sur Generate (UI) dans la section "Common Nx Commands"
Recherchez @aws/nx-plugin - connection
Remplissez les paramètres requis
Cliquez sur Generate

pnpm nx g @aws/nx-plugin:connection

yarn nx g @aws/nx-plugin:connection

npx nx g @aws/nx-plugin:connection

bunx nx g @aws/nx-plugin:connection

Vous pouvez également effectuer une simulation pour voir quels fichiers seraient modifiés

pnpm nx g @aws/nx-plugin:connection --dry-run

yarn nx g @aws/nx-plugin:connection --dry-run

npx nx g @aws/nx-plugin:connection --dry-run

bunx nx g @aws/nx-plugin:connection --dry-run

Sélectionnez votre projet d’agent hôte comme source et votre projet d’agent A2A comme cible. Si vos projets contiennent plusieurs composants, spécifiez les options sourceComponent et targetComponent pour lever l’ambiguïté.

Options

Paramètre	Type	Par défaut	Description
sourceProject Requis	string	-	Le projet source
targetProject Requis	string	-	Le projet cible auquel se connecter
sourceComponent	string	-	Le composant source depuis lequel se connecter (nom du composant, chemin relatif à la racine du projet source, ou identifiant du générateur). Utilisez '.' pour sélectionner explicitement le projet comme source.
targetComponent	string	-	Le composant cible auquel se connecter (nom du composant, chemin relatif à la racine du projet cible, ou identifiant du générateur). Utilisez '.' pour sélectionner explicitement le projet comme cible.
preferInstallDependencies	boolean	true	Indique s'il faut privilégier l'installation des dépendances après l'exécution du générateur. Définir à false pour différer l'installation lors de l'exécution de plusieurs générateurs en lot (une installation s'exécute quand même si nécessaire pour que les générateurs suivants puissent calculer le graphe de projet Nx) ; installer une seule fois à la fin.

Sortie du générateur

Le générateur crée un package partagé agent-connection et modifie le code de votre agent :

Répertoirepackages/common/agent-connection
- Répertoiresrc
  - Répertoireapp
    <target-agent-name>-client-strands.ts Client Strands de haut niveau pour l’agent A2A connecté
  - Répertoirecore
    agentcore-endpoints.ts Résolution ARN/URL indépendante du framework
    agentcore-fetch.ts Fetch SigV4 / JWT / transfert de session indépendant du framework
    agentcore-a2a-client-config.ts Configuration du client A2A indépendante du framework (clientFactory signé)
    agentcore-a2a-client-strands.ts Client A2A Strands encapsulant la configuration
  - index.ts Exporte tous les clients
- project.json
- tsconfig.json

De plus, il :

Transforme le fichier agent.ts de votre agent pour enregistrer l’agent A2A distant en tant que tool Strands
Met à jour la cible serve-local de l’agent pour dépendre de la cible serve-local de l’agent cible
Installe les dépendances requises

Utiliser l’agent A2A connecté

Le générateur transforme le fichier agent.ts de votre agent pour encapsuler l’agent A2A distant en tant qu’outil :

import { Agent, tool } from '@strands-agents/sdk';
import { RemoteAgentClientStrands } from ':my-scope/agent-connection';
import { z } from 'zod';

export const getAgent = async (sessionId: string) => {
  const remoteAgent = await RemoteAgentClientStrands.create(sessionId);
  const remoteAgentTool = tool({
    name: 'askRemoteAgent',
    description: 'Delegate a question to the remote RemoteAgent A2A agent and return its reply.',
    inputSchema: z.object({ prompt: z.string() }),
    callback: async ({ prompt }) => (await remoteAgent.invoke(prompt)).toString(),
  });
  return new Agent({
    systemPrompt: '...',
    tools: [remoteAgentTool],
  });
};

Le paramètre sessionId est transmis depuis l’appelant, garantissant la cohérence pour Bedrock AgentCore Observability.

En coulisses, RemoteAgentClientStrands.create(sessionId) retourne un A2AAgent Strands configuré avec un clientFactory signant SigV4 lorsqu’il est déployé sur AWS, et un endpoint simple http://localhost:<port>/ lorsque LOCAL_DEV=true. La signature et la résolution des endpoints résident dans le fichier agentcore-a2a-client-config.ts indépendant du framework ; seul le mince agentcore-a2a-client-strands.ts dépend de Strands.

Infrastructure

Après avoir exécuté le générateur de connexion, vous devez accorder à l’agent hôte la permission d’invoquer l’agent A2A distant.

CDK
Terraform

const remoteAgent = new RemoteAgent(this, 'RemoteAgent');
const myAgent = new MyAgent(this, 'MyAgent');

// Grant the host agent permission to invoke the remote A2A agent
remoteAgent.grantInvokeAccess(myAgent);

grantInvokeAccess sur un agent A2A configure à la fois bedrock-agentcore:InvokeAgentRuntime et bedrock-agentcore:GetAgentCard — le client A2A a besoin des deux pour récupérer la carte de l’agent et envoyer des messages.

L’ARN du runtime AgentCore de l’agent distant est automatiquement enregistré dans l’espace de noms agentcore de la Configuration d’Exécution par la construction CDK générée, afin que l’agent hôte puisse le découvrir au moment de l’exécution.

module "remote_agent" {
  source = "../../common/terraform/src/app/agents/remote-agent"

  appconfig_application_id  = module.runtime_config_appconfig.application_id
  appconfig_application_arn = module.runtime_config_appconfig.application_arn
}

module "my_agent" {
  source = "../../common/terraform/src/app/agents/my-agent"

  appconfig_application_id  = module.runtime_config_appconfig.application_id
  appconfig_application_arn = module.runtime_config_appconfig.application_arn
}

# Grant the host agent permission to invoke the remote A2A agent
resource "aws_iam_policy" "agent_invoke_a2a" {
  name = "AgentInvokeA2aPolicy"
  policy = jsonencode({
    Version = "2012-10-17"
    Statement = [{
      Effect = "Allow"
      Action = [
        "bedrock-agentcore:InvokeAgentRuntime",
        "bedrock-agentcore:GetAgentCard",
      ]
      Resource = module.remote_agent.agent_core_runtime_arn
    }]
  })
}

resource "aws_iam_role_policy_attachment" "agent_invoke_a2a" {
  role       = module.my_agent.agent_core_runtime_role_arn
  policy_arn = aws_iam_policy.agent_invoke_a2a.arn
}

L’ARN du runtime AgentCore de l’agent distant est automatiquement enregistré dans l’espace de noms agentcore de la Configuration d’Exécution par le module Terraform généré, afin que l’agent hôte puisse le découvrir au moment de l’exécution.

Développement local

Le générateur configure la cible serve-local de l’agent hôte pour :

Démarrer automatiquement le(s) agent(s) A2A connecté(s)
Définir SERVE_LOCAL=true afin que le client généré se connecte directement à http://localhost:<port>/ au lieu d’AgentCore

Exécutez l’agent localement avec :

pnpm nx <agent-name>-dev <project-name>

yarn nx <agent-name>-dev <project-name>

npx nx <agent-name>-dev <project-name>

bunx nx <agent-name>-dev <project-name>

Cela démarrera à la fois l’agent hôte et tous les agents A2A connectés, l’agent hôte appelant les agents distants via HTTP simple sur leurs ports locaux assignés.