Planeamento e tarefas

Importe e construa os providers e, em seguida, adicione-os através de 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();

Personalize os nomes e instruções dos modos com AgentModeProviderOptions.Modes. O fornecedor .NET todo armazena o estado em AgentSession.StateBag. TodoProviderOptions pode substituir as suas instruções, suprimir a mensagem da lista de tarefas injetada ou fornecer um construtor de mensagens personalizado.

As instruções predefinidas plan incluem escrever o plano na memória de ficheiros. Se o agente composto manualmente não fornecer ferramentas de memória de ficheiros, personalize as instruções de modo ou adicione um fornecedor de memória adequado.

Alterar os modos na aplicação

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

Use GetModeAsync para ler o modo atual.

Importa e constrói os providers e, em seguida, adiciona-os a um elemento Agent normal:

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 usa TodoSessionStore por defeito. Use TodoFileStore ou um TodoStore personalizado quando o estado de tarefas pendentes tiver de ser armazenado fora da carga útil da sessão. Personalizar modos com AgentModeProvider(mode_instructions={...}).

As instruções padrão plan incluem escrever o plano na memória de ficheiros. Se o agente composto manualmente não fornecer ferramentas de memória de ficheiros, personalize mode_instructions ou adicione um fornecedor de memória adequado.

Alterar modos na aplicação

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,
)

Envolva o agente composto manualmente com LoopAgent. TodoCompletionLoopEvaluator pode restringir a repetição aos modos selecionados:

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

Adicione AgentLoopMiddleware ao agente normal e use todos_remaining() com um filtro de modo:

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,
        )
    ],
)

A integração de ciclos baseada em Todo não está atualmente disponível em Go.

HarnessAgent ativa TodoProvider e AgentModeProvider por defeito. Configure o fornecedor de modo e o ciclo opcional orientado por TODOs através 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();

Defina DisableTodoProvider ou DisableAgentModeProvider para remover um fornecedor predefinido. Para usar um TodoProvider configurado, desative a predefinição e adicione a sua instância através de AIContextProviders. Pode resolver os fornecedores habilitados através de agent.GetService<TProvider>().

create_harness_agent Ativa ambos os fornecedores por defeito. Forneça instâncias configuradas para as substituir e adicione um ciclo opcional orientado por TODO:

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()

Defina disable_todo ou disable_mode para remover um fornecedor padrão. O harness de Python ativa o middleware de aprovação automática de ferramentas por defeito, por isso, deve passar session em cada execução.