Planification et tâches

Importez et construisez les fournisseurs, puis ajoutez-les via ChatClientAgentOptions.AIContextProviders:

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

var todoProvider = new TodoProvider();
var modeProvider = new AgentModeProvider(
    new AgentModeProviderOptions
    {
        DefaultMode = "plan",
    });

AIAgent agent = chatClient.AsAIAgent(new ChatClientAgentOptions
{
    AIContextProviders = [todoProvider, modeProvider],
});

AgentSession session = await agent.CreateSessionAsync();

Personnaliser les noms et instructions du mode avec AgentModeProviderOptions.Modes. Le fournisseur de gestion des tâches .NET stocke l’état dans AgentSession.StateBag. TodoProviderOptions peut remplacer ses instructions, supprimer le message todo-list injecté ou fournir un générateur de messages personnalisé.

Les instructions par défaut plan incluent l’écriture du plan dans la mémoire du fichier. Si l’agent composé manuellement ne fournit pas d’outils de mémoire de fichier, personnalisez les instructions de mode ou ajoutez un fournisseur de mémoire approprié.

Modifier les modes de l’application

await modeProvider.SetModeAsync(session, "execute");

Utilisez GetModeAsync pour lire le mode actuel.

Importez et construisez les fournisseurs de service, puis ajoutez-les à un Agent classique :

from agent_framework import (
    Agent,
    AgentModeProvider,
    TodoFileStore,
    TodoProvider,
)

todo_provider = TodoProvider(
    store=TodoFileStore("./todo-state"),
)
mode_provider = AgentModeProvider(
    default_mode="plan",
)

agent = Agent(
    client=client,
    context_providers=[todo_provider, mode_provider],
)

session = agent.create_session()

TodoProvider utilise TodoSessionStore par défaut. Utilisez TodoFileStore ou votre propre TodoStore si l’état des tâches à faire doit être stocké en dehors de la charge utile de la session. Personnaliser les modes avec AgentModeProvider(mode_instructions={...}).

Les instructions par défaut plan incluent l’écriture du plan dans la mémoire du fichier. Si l’agent composé manuellement ne fournit pas d’outils de mémoire de fichier, personnalisez mode_instructions ou ajoutez un fournisseur de mémoire approprié.

Modifier les modes de l’application

from agent_framework import get_agent_mode, set_agent_mode

set_agent_mode(
    session,
    "execute",
    source_id=mode_provider.source_id,
    available_modes=mode_provider.available_modes,
)

current_mode = get_agent_mode(
    session,
    source_id=mode_provider.source_id,
    default_mode=mode_provider.default_mode,
    available_modes=mode_provider.available_modes,
)

Encapsulez l’agent composé manuellement avec LoopAgent. TodoCompletionLoopEvaluator peut restreindre la boucle aux modes sélectionnés :

AIAgent loopingAgent = new LoopAgent(
    agent,
    new TodoCompletionLoopEvaluator(
        new TodoCompletionLoopEvaluatorOptions
        {
            Modes = ["execute"],
        }),
    new LoopAgentOptions { MaxIterations = 10 });

Ajoutez AgentLoopMiddleware à l’agent standard et utilisez-le todos_remaining() avec un filtre de mode :

from agent_framework import (
    Agent,
    AgentLoopMiddleware,
    todos_remaining,
    todos_remaining_message,
)

agent = Agent(
    client=client,
    context_providers=[todo_provider, mode_provider],
    middleware=[
        AgentLoopMiddleware(
            todos_remaining(looping_modes=["execute"]),
            next_message=todos_remaining_message,
            max_iterations=10,
        )
    ],
)

L’intégration de boucle pilotée par les TODO n’est actuellement pas disponible en Go.

HarnessAgent active TodoProvider et AgentModeProvider par défaut. Configurez le fournisseur du mode et la boucle optionnelle pilotée par les TODO à l’aide de HarnessAgentOptions:

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

var options = new HarnessAgentOptions
{
    AgentModeProviderOptions = new AgentModeProviderOptions
    {
        DefaultMode = "plan",
    },
    LoopEvaluators =
    [
        new TodoCompletionLoopEvaluator(
            new TodoCompletionLoopEvaluatorOptions
            {
                Modes = ["execute"],
            }),
    ],
    LoopAgentOptions = new LoopAgentOptions { MaxIterations = 10 },
};

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

Définissez DisableTodoProvider ou DisableAgentModeProvider pour supprimer un fournisseur par défaut. Pour utiliser un paramètre configuré TodoProvider, désactivez la valeur par défaut et ajoutez votre instance via AIContextProviders. Vous pouvez résoudre les fournisseurs activés via agent.GetService<TProvider>().

create_harness_agent active les deux fournisseurs par défaut. Fournissez des instances configurées pour les remplacer et ajoutez une boucle todo-pilotée facultative :

from agent_framework import (
    AgentModeProvider,
    TodoFileStore,
    TodoProvider,
    create_harness_agent,
    todos_remaining,
    todos_remaining_message,
)

todo_provider = TodoProvider(store=TodoFileStore("./todo-state"))
mode_provider = AgentModeProvider(default_mode="plan")

agent = create_harness_agent(
    client=client,
    todo_provider=todo_provider,
    mode_provider=mode_provider,
    loop_should_continue=todos_remaining(looping_modes=["execute"]),
    loop_next_message=todos_remaining_message,
    loop_max_iterations=10,
)
session = agent.create_session()

Définissez disable_todo ou disable_mode pour supprimer un fournisseur par défaut. Le harnais Python active par défaut l’intergiciel d’approbation automatique des outils ; passez donc session à chaque exécution.