Planering och att göra-lista

Två kontextleverantörer stöder långvarigt arbete:

  • En att göra-leverantör lagrar spårbara arbetsobjekt och ger agentverktygen att lägga till, slutföra, ta bort och inspektera dem.
  • En agentlägesprovider lagrar det aktuella driftläget och ger agentverktygen att läsa eller ändra det.

Kombinera dessa leverantörer direkt när du bara behöver planering, eller använd Harness Agent för att aktivera båda som en del av dess mer omfattande standardpipeline.

Att göra-verktyg

Leverantörerna .NET och Python exponerar samma modellinriktade verktyg:

Tool Purpose
todos_add Lägg till ett eller flera objekt med en rubrik och en valfri beskrivning.
todos_complete Markera ett eller flera slutförda objekt och inkludera en orsak till slutförandet.
todos_remove Ta bort objekt som inte längre är relevanta.
todos_get_remaining Returnera ofullständiga objekt.
todos_get_all Returnera fullständiga och ofullständiga objekt.

Providern matar in den aktuella att göra-listan före varje körning, så att agenten kan återuppta utestående arbete.

Planerings- och körningslägen

AgentModeProvider har plan- och executelägen som standard:

  1. Planen är interaktiv. Agenten analyserar kraven, skapar att göra-punkter, ställer klargörande frågor, presenterar en plan och frågar innan den byter läge.
  2. Execute är autonomt. Agenten arbetar med planen, gör rimliga val när informationen är tvetydig och markerar todos slutförd.

Providern exponerar mode_get och mode_set. Dess instruktioner instruerar modellen att endast använda mode_set när användaren uttryckligen tillåter övergången. Program kan också ändra läget direkt, vilket gör att providern matar in ett lägesändringsmeddelande vid nästa körning.

Konfigurera planering och att göra-uppgifter manuellt

Importera och konstruera leverantörerna och lägg sedan till dem 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();

Anpassa lägesnamn och instruktioner med AgentModeProviderOptions.Modes. Todo-providern för .NET lagrar tillståndet i AgentSession.StateBag. TodoProviderOptions kan ersätta instruktionerna, utelämna det inmatade todo-listmeddelandet eller tillhandahålla en anpassad meddelandeskapare.

Standardinstruktionerna plan innefattar att skriva planen i filminnet. Om den manuellt sammansatta agenten inte tillhandahåller filminnesverktyg kan du anpassa lägesinstruktionerna eller lägga till en lämplig minnesprovider.

Ändra lägen från programmet

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

Använd GetModeAsync för att läsa det aktuella läget.

Importera och konstruera leverantörerna och lägg sedan till dem i en vanlig Agent:

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 använder TodoSessionStore som standard. Använd TodoFileStore eller en anpassad TodoStore när att göra-tillstånd måste lagras utanför sessionsnyttolasten. Anpassa lägen med AgentModeProvider(mode_instructions={...}).

Standardinstruktionerna plan inbegriper att skriva planen i filminnet. Om den manuellt sammansatta agenten inte tillhandahåller filminnesverktyg kan du anpassa mode_instructions eller lägga till en lämplig minnesprovider.

Ändra lägen från programmet

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

Anmärkning

De paketerade todo- och agentlägesprovidrar som beskrivs på den här sidan är för närvarande inte tillgängliga i Go.

Kör planen manuellt tills den är slutförd

Todo-spårning registrerar framsteg men återanropar inte agenten på egen hand. Kombinera den med en avgränsad agent loop när exekveringsläget ska fortsätta tills alla uppgifter är slutförda:

Omslut den manuellt skapade agenten med LoopAgent. TodoCompletionLoopEvaluator kan begränsa loopning till valda lägen:

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

Lägg till AgentLoopMiddleware i den vanliga agenten och använd todos_remaining() med ett lägesfilter:

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

TODO-styrd loop-integration är för närvarande inte tillgänglig i Go.

Använd planering och att göra-listor med Harness Agent

Använd den här konfigurationen när du också vill ha Harness-agentens förkonfigurerade pipeline för historik, minne, godkännande och observerbarhet.

HarnessAgent aktiverar TodoProvider och AgentModeProvider som standard. Konfigurera lägesleverantören och den valfria todo-styrda loopen genom 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();

Ange DisableTodoProvider eller DisableAgentModeProvider ta bort en standardprovider. Om du vill använda en konfigurerad TodoProviderinaktiverar du standardinställningen och lägger till din instans via AIContextProviders. Du kan lösa aktiverade leverantörer via agent.GetService<TProvider>().

create_harness_agent aktiverar båda leverantörerna som standard. Ange konfigurerade instanser för att ersätta dem och lägg till en valfri todo-driven loop:

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

Ange disable_todo eller disable_mode ta bort en standardprovider. Python-ramverket aktiverar mellanprogramvara för automatisk verktygsgodkänning som standard, så skicka med session vid varje körning.

Anmärkning

Harness Agent-planering och todo-providers är för närvarande inte tillgängliga i Go.

Sessionsbeteende

Använd samma session över varv. Lägestillståndet lagras i sessionen i båda SDK:erna. .NET:s att-göra-tillstånd lagras i AgentSession.StateBag; Python använder TodoSessionStore som standard, medan TodoFileStore eller en anpassad TodoStore kan användas för att lagra att-göra-data externt.

Ändringsläge från programkod köar ett meddelande om engångslägesändring för nästa körning. Det modellriktade mode_set verktyget köar inte det extra meddelandet eftersom modellen redan har observerat sitt eget verktygsanrop.

Bekräftelsen av planering till utförande är ett beteende på instruktionsnivå, inte en begäran om godkännande för ett verktyg. Själva verktygen todo och mode kräver inte godkännande av funktioner; programkoden kan ändra lägen direkt när värdprogrammet redan har fått den behörighet som krävs.

Nästa steg

Förstå Agent Harness-strukturen

Gå djupare

  • Last updated on