Planificación y tareas pendientes

Importe y construya los proveedores y agréguelos a travé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();

Personalice los nombres de modo e instrucciones con AgentModeProviderOptions.Modes. El proveedor de tareas pendientes .NET almacena el estado en AgentSession.StateBag. TodoProviderOptions puede reemplazar sus instrucciones, suprimir el mensaje de lista de tareas pendientes insertado o proporcionar un generador de mensajes personalizado.

Las instrucciones predeterminadas plan incluyen escribir el plan en la memoria del archivo. Si el agente compuesto manualmente no proporciona herramientas de memoria de archivos, personalice las instrucciones de modo o agregue un proveedor de memoria adecuado.

Cambiar los modos desde la aplicación

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

Use GetModeAsync para leer el modo actual.

Importe y construya los proveedores; a continuación, agréguelos a un 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 de forma predeterminada. Utiliza TodoFileStore o un TodoStore personalizado cuando el estado de las tareas pendientes deba almacenarse fuera de la carga útil de la sesión. Personalice los modos con AgentModeProvider(mode_instructions={...}).

Las instrucciones predeterminadas plan incluyen escribir el plan en la memoria del archivo. Si el agente compuesto manualmente no proporciona herramientas de memoria de archivos, personalice mode_instructions o agregue un proveedor de memoria adecuado.

Cambiar los modos desde la aplicación

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

Omita available_modes para usar los modos integrados plan y execute. Si se proporciona available_modes, debe contener al menos un modo; una secuencia vacía provoca ValueError antes de que se cambie el estado de la sesión.

Herramientas del modo de control desde la aplicación

Oculte la herramienta en modo integrada cuando la aplicación proporciona su propia interfaz de usuario o herramienta orientada al modelo:

mode_provider = AgentModeProvider(
    default_mode="plan",
    expose_mode_set=False,
    expose_mode_get=False,
)

Las dos opciones son independientes y tienen como valor predeterminado True. Ocultar ambas herramientas conserva el estado del modo asociado a la sesión, las instrucciones en cada turno y las notificaciones externas de cambio de modo. Añadir una herramienta de sustitución orientada al modelo a través del argumento tools del agente y hacer que llame a set_agent_mode(..., notify=False) porque el modelo ya observa el resultado de esa herramienta. Los cambios en la aplicación o la interfaz de usuario pueden mantener el valor predeterminado notify=True para que el agente reciba la notificación de cambios en su siguiente ejecución.

Envuelve el agente compuesto manualmente con LoopAgent. TodoCompletionLoopEvaluator puede restringir el bucle a los modos seleccionados:

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

Agregue AgentLoopMiddleware al agente normal y use todos_remaining() con un 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,
        )
    ],
)

La integración con bucles controlados por TODO no está disponible actualmente en Go.

HarnessAgent habilita TodoProvider y AgentModeProvider de forma predeterminada. Configura el proveedor de modo y el bucle opcional basado en tareas pendientes a travé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();

Establezca DisableTodoProvider o DisableAgentModeProvider para quitar un proveedor predeterminado. Para usar una instancia de TodoProvider configurada, deshabilite el valor predeterminado y añada su instancia mediante AIContextProviders. Puedes resolver los proveedores habilitados a través de agent.GetService<TProvider>().

create_harness_agent habilita ambos proveedores de forma predeterminada. Proporcione instancias configuradas para sustituirlas y añada un bucle opcional basado en 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()

Establezca disable_todo o disable_mode para quitar un proveedor predeterminado. El entorno de ejecución de Python activa de forma predeterminada el middleware de aprobación automática de herramientas, por lo que debes pasar session en cada ejecución.