Agents en arrière-plan

Importez BackgroundAgentsProvider et ajoutez-le à un agent standard via ChatClientAgentOptions.AIContextProviders:

using Microsoft.Agents.AI;
using Microsoft.Extensions.AI;

var backgroundProvider = new BackgroundAgentsProvider(
    [webSearchAgent, codeAnalysisAgent]);

AIAgent parentAgent = chatClient.AsAIAgent(new ChatClientAgentOptions
{
    Name = "research-coordinator",
    AIContextProviders = [backgroundProvider],
});

AgentSession session = await parentAgent.CreateSessionAsync();

BackgroundAgentsProviderOptions personnalise les instructions du fournisseur et la mise en forme de liste d’agents.

from agent_framework import Agent, BackgroundAgentsProvider

background_provider = BackgroundAgentsProvider(
    [web_search_agent, code_analysis_agent],
    wait_timeout_seconds=30,
)

parent_agent = Agent(
    client=client,
    name="research-coordinator",
    context_providers=[background_provider],
)
session = parent_agent.create_session()

Transmettez instructions= à BackgroundAgentsProvider pour remplacer ses instructions. Insérez {background_agents} à l’endroit où la liste des agents enfants mise en forme doit apparaître.

wait_timeout_seconds définit la durée pendant laquelle chaque appel attend background_agents_wait_for_first_completion . Il doit s’agir d’un entier positif et est défini par défaut sur 300 secondes. Si le délai d’expiration expire, l’outil retourne normalement et laisse les tâches en cours d’exécution, afin que le parent puisse l’appeler à nouveau.

Lorsque l’hôte évince ou abandonne une session parent, libérez la tâche du fournisseur en cours de traitement et les descripteurs de session enfant dans un bloc finally :

session = parent_agent.create_session()
try:
    await parent_agent.run("Coordinate the research.", session=session)
finally:
    await background_provider.release_session(session)

release_session(session, *, cancel_running=True, timeout=30.0) est une API de cycle de vie côté hôte, et non un outil orienté modèle. Par défaut, elle annule les tâches enfants en cours d’exécution et attend jusqu’à 30 secondes que l’annulation prenne effet avant de libérer tout l’état d’exécution de la session parente. Définissez cancel_running=False pour rejeter la publication tant que des tâches sont en cours d’exécution, ou définissez timeout=None pour attendre indéfiniment.

En revanche, background_agents_clear_completed_task permet au modèle de supprimer une tâche de terminal et sa session enfant pendant une conversation. Il refuse les tâches en cours d’exécution et ne remplace pas la fermeture de la session parente côté hôte.

Entourez l’élément parent composé manuellement avec LoopAgent. BackgroundTaskCompletionLoopEvaluator continue uniquement pendant qu’une tâche reste dans l’état Running :

AIAgent loopingParent = new LoopAgent(
    parentAgent,
    new BackgroundTaskCompletionLoopEvaluator(),
    new LoopAgentOptions { MaxIterations = 10 });

L’évaluateur s’arrête pour les tâches terminées, en échec et perdues.

Ajoutez AgentLoopMiddleware au parent standard et associez le prédicat de tâche d’arrière-plan à son assistant de message suivant :

from agent_framework import (
    Agent,
    AgentLoopMiddleware,
    background_tasks_running,
    background_tasks_running_message,
)

parent_agent = Agent(
    client=client,
    context_providers=[background_provider],
    middleware=[
        AgentLoopMiddleware(
            background_tasks_running(),
            next_message=background_tasks_running_message,
            max_iterations=10,
        )
    ],
)

Le prédicat reste vrai uniquement tant que l’état persistant de la tâche indique encore qu’une tâche est en cours d’exécution.

L’intégration automatique de boucles de tâche en arrière-plan n’est actuellement pas disponible dans Go.

Définissez HarnessAgentOptions.BackgroundAgents. Ajoutez l’évaluateur d’achèvement lorsque le parent doit continuer à s’exécuter tant que le travail délégué n’est plus en cours d’exécution :

using Microsoft.Agents.AI;
using Microsoft.Extensions.AI;

var options = new HarnessAgentOptions
{
    Name = "research-coordinator",
    BackgroundAgents = [webSearchAgent, codeAnalysisAgent],
    LoopEvaluators = [new BackgroundTaskCompletionLoopEvaluator()],
    LoopAgentOptions = new LoopAgentOptions { MaxIterations = 10 },
};

HarnessAgent parentAgent = chatClient.AsHarnessAgent(options);
// Equivalent construction: new HarnessAgent(chatClient, options)
AgentSession session = await parentAgent.CreateSessionAsync();

Utilisez HarnessAgentOptions.BackgroundAgentsProviderOptions pour personnaliser les instructions du fournisseur et la mise en forme de la liste des agents. Omettre LoopEvaluators permet de conserver la délégation en arrière-plan disponible sans nouvelle invocation automatique.

Fournir background_agents à create_harness_agent. Associez-la à une boucle délimitée lorsque le parent doit attendre automatiquement :

from agent_framework import (
    background_tasks_running,
    background_tasks_running_message,
    create_harness_agent,
)

parent_agent = create_harness_agent(
    client=client,
    name="research-coordinator",
    background_agents=[web_search_agent, code_analysis_agent],
    background_agents_wait_timeout_seconds=30,
    loop_should_continue=background_tasks_running(),
    loop_next_message=background_tasks_running_message,
    loop_max_iterations=10,
)
session = parent_agent.create_session()

Permet background_agents_instructions de remplacer les instructions du fournisseur. background_agents_wait_timeout_seconds configure la même attente limitée que wait_timeout_seconds sur BackgroundAgentsProvider. Le harnais Python active par défaut l’intergiciel d’approbation automatique des outils ; passez donc session à chaque exécution.