Ajouter une étape d'agent existante

Vous pouvez ajouter des agents IA existants en tant qu'étapes de votre workflow pour transférer des tâches à des agents spécialisés. Cela vous permet de composer des workflows multi-agents qui s'orchestre entre différents agents, chacun gérant une partie spécifique d'un processus plus vaste.

Avant de commencer

Avant d'utiliser cette fonctionnalité, procédez comme suit :

  • Assurez-vous qu'un administrateur Gemini Enterprise a activé le bouton d'activation de la fonctionnalité Workflow Builder dans les paramètres de gestion des fonctionnalités de votre application. Pour en savoir plus, consultez Gérer les fonctionnalités des applications Web.

  • Assurez-vous que les agents que vous souhaitez ajouter sont disponibles dans votre organisation. Cette fonctionnalité permet d'ajouter les agents suivants :

Ajouter une étape d'agent existant

Application

  1. Ouvrez votre application Web Gemini Enterprise dans un navigateur.
  2. Accédez à un agent existant ou créez-en un.
  3. Dans le générateur de flux, cliquez sur Ajouter une étape.
  4. Dans le panneau Ajouter une étape, cliquez sur Agents existants pour développer la section.

  5. Parcourez la liste des agents disponibles.

  6. Cliquez sur l'agent que vous souhaitez ajouter.

    Le système ajoute l'étape d'agent existant à votre workflow. L'agent sélectionné s'exécute dans le cadre de votre workflow, reçoit des entrées des étapes précédentes et transmet des sorties aux étapes ultérieures.

  7. Dans le canevas, cliquez sur l'étape d'agent existant pour ouvrir son panneau de configuration, puis configurez les éléments suivants :

    • Prompt : saisissez le prompt ou les instructions utilisés pour déclencher l' agent. Vous pouvez inclure du texte statique ou des sorties de référence à partir d'étapes précédentes (par exemple, ${step_name.output}).

L'étape d'agent est une référence dynamique à l'agent sélectionné. Si l'agent source est mis à jour ou qu'une nouvelle version est mise en ligne, votre workflow utilise automatiquement la version la plus récente.

Pour en savoir plus sur les limites de cette fonctionnalité, consultez Problèmes connus et limites.

Fonctionnement des questions de clarification

Lorsqu'un agent existant s'exécute dans un workflow, il peut mettre en pause l'exécution pour poser une question de clarification à l'utilisateur s'il a besoin d'informations manquantes pour terminer sa tâche. Les questions de clarification sont prises en charge de manière native lorsque l'agent référencé émet un signal input-required (A2A) ou un événement RequestInput (ADK).

Lorsqu'une étape d'agent existant s'exécute et nécessite des informations supplémentaires :

  1. L'exécution est mise en pause : le workflow met en pause l'exécution à l'étape d'agent existant et lance un prompt d'intervention humaine (HITL).
  2. L'utilisateur répond au prompt : l'application Web Gemini Enterprise affiche la question de clarification de l'agent à l'utilisateur, ainsi qu'un champ de texte dans lequel il peut saisir sa réponse.
  3. L'exécution reprend : lorsque l'utilisateur envoie sa réponse, le workflow reprend l'agent existant, en lui transmettant la réponse de l'utilisateur.
  4. Prise en charge de plusieurs tours de conversation : l'agent peut poser plusieurs questions de clarification successivement sur plusieurs tours de conversation jusqu'à ce qu'il collecte toutes les informations requises et produise sa sortie finale.

Isolement du contexte

Lors d'un échange de questions de clarification, l'agent référencé ne reçoit que son propre historique d'interaction avec l'utilisateur et le prompt initial configuré pour le nœud. Les sorties et les variables des autres étapes du workflow ne sont pas automatiquement transmises à l'agent référencé, sauf si elles sont explicitement référencées dans le prompt de l'étape.

Implémenter des questions de clarification dans votre agent

Pour prendre en charge les questions de clarification, configurez votre agent personnalisé afin qu'il émette un signal d'entrée de requête au niveau du protocole lorsqu'il a besoin d'informations supplémentaires.

Agents A2A (natifs)

Pour les agents qui implémentent directement le protocole Agent-to-Agent (A2A), renvoyez la tâche à l'état input-required avec TaskUpdater, en fournissant la question de clarification dans la charge utile du message :

from a2a.server.tasks import TaskUpdater
from a2a.types import Message, Part, Role, TextPart

# Inside your custom agent's task executor class:
async def execute(self, context, event_queue):
    updater = TaskUpdater(event_queue, context.task_id, context.context_id)
    if context.current_task is None:
        await updater.submit()
    await updater.start_work()

    user_input = context.get_user_input()
    if "weather" in user_input and "tokyo" not in user_input.lower():
        await updater.requires_input(
            Message(
                message_id=f"q-{context.task_id}",
                role=Role.agent,
                parts=[Part(root=TextPart(
                    text="Which city would you like the weather for?"))],
                task_id=context.task_id,
                context_id=context.context_id,
            )
        )
        return

    await updater.complete(
        Message(
            message_id=f"a-{context.task_id}",
            role=Role.agent,
            parts=[Part(root=TextPart(
                text="It is sunny and 72°F in Tokyo."))],
            task_id=context.task_id,
            context_id=context.context_id,
        )
    )

La réponse de l'utilisateur est renvoyée à votre agent sous la forme d'une requête message/send avec le même taskId.

Agents A2A (créés avec ADK)

Si votre agent est créé avec Agent Development Kit (ADK) et exposé via A2A (à l'aide de to_a2a()), encapsulez votre fonction de question dans LongRunningFunctionTool :

from google.adk.agents import Agent
from google.adk.tools.long_running_tool import LongRunningFunctionTool
from google.adk.a2a.utils.agent_to_a2a import to_a2a

def get_weather(city: str) -> str:
    """Returns weather information for a city."""
    return f"It is sunny and 72°F in {city}."

def ask_clarifying_question(question: str) -> None:
    """Asks the user a question and waits for their reply."""
    return None

root_agent = Agent(
    model="gemini-2.5-flash",
    name="weather_agent",
    instruction=(
        "If the user asks for weather without specifying a city, call "
        "`ask_clarifying_question` and wait. Do not guess."
    ),
    tools=[get_weather, LongRunningFunctionTool(ask_clarifying_question)],
)

a2a_app = to_a2a(root_agent, port=8000)

Agents ADK sur Agent Engine

Pour les agents ADK hébergés par le moteur de raisonnement sur Agent Engine, émettez un événement RequestInput dans un outil de générateur ou une étape d'agent personnalisé :

from google.adk.events import RequestInput

# Inside a generator tool or custom agent step
def ask_for_details():
    """Requests user input during tool or step execution."""
    yield RequestInput(
        interrupt_id="weather_city",
        message="Which city would you like the weather for?",
    )

Étape suivante