Passaggio 6: Agent Harness

Creare un agente harness da qualsiasi elemento IChatClient con il metodo di estensione AsHarnessAgent. Poiché un harness gestisce le attività in modo interattivo in più passaggi, in genere viene controllato da un ciclo di conversazione: mantenere un elemento AgentSession affinché lo stato dell'harness (piano, attività e cronologia) venga mantenuto tra i turn, leggere l'istruzione successiva dell'utente e trasmettere in streaming l'output dell'agente man mano che viene prodotto.

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

// chatClient is any IChatClient implementation (Foundry, Azure OpenAI, OpenAI, Anthropic, ...).
AIAgent agent = chatClient.AsHarnessAgent();

// A session carries the harness state (plan, todos, history) across turns.
AgentSession session = await agent.CreateSessionAsync();

Console.WriteLine("Harness agent ready. Type 'exit' to quit.");
while (true)
{
    Console.Write("> ");
    string? input = Console.ReadLine();
    if (string.IsNullOrWhiteSpace(input) || input.Equals("exit", StringComparison.OrdinalIgnoreCase))
    {
        break;
    }

    // Stream this turn's output as the harness plans and works through the request.
    await foreach (var update in agent.RunStreamingAsync(input, session))
    {
        Console.Write(update);
    }

    Console.WriteLine();
}

L'harness gestisce pianificazione, monitoraggio delle attività e persistenza della cronologia nell'intera conversazione. Per una console completa, con prompt di approvazione degli strumenti, rendering di attività/modalità e comandi slash, vedere l'esperienza utente del terminale di esempio.

L'esempio completo crea un client di chat Microsoft Foundry, lo racchiude con create_harness_agent e riutilizza una sessione tra due turni. L'harness aggiunge pianificazione, rilevamento to-do e compattazione mentre l'esempio disabilita la memoria dei file e la ricerca Web per rimanere concentrato.

import asyncio

from agent_framework import create_harness_agent
from agent_framework.foundry import FoundryChatClient
from azure.identity import AzureCliCredential


async def main() -> None:
    agent = create_harness_agent(
        client=FoundryChatClient(
            project_endpoint="https://your-account.services.ai.azure.com/api/projects/your-project",
            model="gpt-6-luna",
            credential=AzureCliCredential(),
        ),
        agent_instructions="Help users plan and complete multi-step tasks.",
        disable_file_memory=True,
        disable_web_search=True,
    )
    session = agent.create_session()

    print(await agent.run("Plan a weekend trip to Seattle.", session=session))
    print(await agent.run("Turn that plan into a checklist.", session=session))


if __name__ == "__main__":
    asyncio.run(main())

La sessione condivisa mantiene lo stato di harness in entrambe le chiamate. Per una console con funzionalità complete, con richieste di approvazione degli strumenti, visualizzazione delle attività e delle modalità e comandi slash, vedere l'esperienza utente del terminale di esempio.

Prerequisites

• Go 1.26 o successive.
• Una copia locale del repository di Agent Framework Go.
• Endpoint del progetto Foundry e distribuzione del modello configurati tramite FOUNDRY_PROJECT_ENDPOINT e FOUNDRY_MODEL.
• Una credenziale Azure supportata da DefaultAzureCredential, ad esempio un accesso di interfaccia della riga di comando di Azure con az login.

Configurare l'harness Go

Il pacchetto agent/harness configura un normale agente basato su provider. Passare il risultato di harness.AgentConfig al costruttore del provider:

import (
    "context"
    "fmt"
    "os"
    "path/filepath"

    "github.com/microsoft/agent-framework-go/agent"
    "github.com/microsoft/agent-framework-go/agent/harness"
    "github.com/microsoft/agent-framework-go/examples/internal/demo"
    "github.com/microsoft/agent-framework-go/message"
    "github.com/microsoft/agent-framework-go/provider/foundryprovider"
)
    workingDirectory, err := os.Getwd()
    if err != nil {
        return fmt.Errorf("get working directory: %w", err)
    }
    cfg, err := harness.AgentConfig(harness.Config{WorkingDirectory: workingDirectory}, agent.Config{
        Name:        "HarnessAssistant",
        Middlewares: []agent.Middleware{logger},
    })
    if err != nil {
        return err
    }
    a := foundryprovider.NewAgent(
        demo.FoundryProjectEndpoint,
        demo.FoundryTokenCredential(),
        foundryprovider.ModelDeployment(demo.FoundryModel),
        foundryprovider.AgentConfig{
            Config:             cfg,
            DisableStoreOutput: true,
            Instructions:       "Help with software engineering tasks. Use memory and todos to track the current session's work.",
        },
    )

Le impostazioni predefinite includono todos, modalità di pianificazione ed esecuzione, memoria dei file isolati dalla sessione, skills, ricerca Web ospitata, middleware di approvazione degli strumenti e strumentazione OpenTelemetry. L'helper abilita anche la persistenza della cronologia per ogni chiamata di servizio e l'inserimento di messaggi.

Questo esempio di Foundry imposta DisableStoreOutput: true in modo che la cronologia locale gestisca la conversazione. Impostare DisableWebSearch in harness.Config se il provider o la distribuzione selezionati non supporta la ricerca Web ospitata.

Eseguire l'esempio completo dalla radice del repository Go:

go run .\examples\02-agents\harness\step04_composite_harness

L'esempio riutilizza una sessione in due turni, gestisce le richieste di approvazione degli strumenti e apre una sessione separata per dimostrare l'isolamento della memoria. La memoria dei file persiste in agent-file-memory nella directory di lavoro.

La compattazione e il loop sono consensi espliciti invece di usare le impostazioni predefinite dell'harness Go. Per i limiti di configurazione e dei componenti, vedere Harness dell'agente.