TypeScript Agent vers A2A Agent

Le générateur connection peut connecter votre TypeScript Agent à un agent A2A distant — soit TypeScript soit 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 Strands Agent (n’importe quel protocole)
Un projet avec un composant Agent généré avec --protocol=a2a et --auth=iam (soit ts#agent soit py#agent)
Les deux composants créés avec infra: agentcore

Utilisation

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

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

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 High-level Strands client for the connected A2A agent
  - Répertoirecore
    agentcore-endpoints.ts Framework-agnostic ARN/URL resolution
    agentcore-fetch.ts Framework-agnostic SigV4 / JWT / session-forwarding fetch
    agentcore-a2a-client-config.ts Framework-agnostic A2A client config (signed clientFactory)
    agentcore-a2a-client-strands.ts Strands A2A client wrapping the config
  - index.ts Exports all clients
- project.json
- tsconfig.json

De plus, il :

Transforme le fichier agent.ts de votre agent pour enregistrer l’agent A2A distant en tant qu’tool Strands
Met à jour la cible dev de l’agent pour dépendre de la cible dev 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 l’observabilité Bedrock AgentCore.

Sous le capot, RemoteAgentClientStrands.create(sessionId) retourne un A2AAgent Strands configuré avec une clientFactory signant SigV4 lorsqu’il est déployé sur AWS, et un point de terminaison http://localhost:<port>/ simple lorsque LOCAL_DEV=true. La signature et la résolution du point de terminaison se trouvent 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 d’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 à 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 à l’exécution.

Développement local

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

Démarrer automatiquement le(s) agent(s) A2A connecté(s)
Définir LOCAL_DEV=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.