Funktionswerkzeuge mit Genehmigungsverfahren durch den Menschen nutzen

In diesem Schritt des Tutorials wird gezeigt, wie Sie Funktionstools verwenden, die eine menschliche Genehmigung durch einen Agenten erfordern, bei dem der Agent auf dem Azure OpenAI Chat Completion Service basiert.

Wenn Agents eine Benutzereingabe erfordern, z. B. zum Genehmigen eines Funktionsaufrufs, wird dies als "Human-in-the-Loop"-Muster bezeichnet. Ein Agentenlauf, der eine Benutzereingabe erfordert, liefert eine Antwort, die angibt, welche Eingabe vom Benutzer erforderlich ist, anstatt mit einer endgültigen Antwort abzuschließen. Der Anrufer des Agents ist dann dafür verantwortlich, die erforderlichen Eingaben vom Benutzer zu erhalten und sie im Rahmen eines neuen Agentendurchlaufs an den Agenten zurückzugeben.

Voraussetzungen

Für Voraussetzungen und die Installation von NuGet-Paketen siehe den Schritt Erstellen und Ausführen eines einfachen Agenten in diesem Tutorial.

Erstellen Sie den Agenten mit Funktionstools

Bei der Verwendung von Funktionen ist es möglich, für jede Funktion anzugeben, ob sie eine menschliche Genehmigung erfordert, bevor sie ausgeführt wird. Dazu wird die AIFunction Instanz in eine ApprovalRequiredAIFunction Instanz umschlossen.

Hier ist ein Beispiel für ein einfaches Funktionstool, das das Wetter für einen bestimmten Ort fälscht.

using System;
using System.ComponentModel;
using System.Linq;
using Azure.AI.Projects;
using Azure.Identity;
using Microsoft.Agents.AI;
using Microsoft.Extensions.AI;

[Description("Get the weather for a given location.")]
static string GetWeather([Description("The location to get the weather for.")] string location)
    => $"The weather in {location} is cloudy with a high of 15°C.";

Gehen Sie wie folgt vor, um eine Datei AIFunction zu erstellen und dann in eine ApprovalRequiredAIFunctionumzuschließen:

AIFunction weatherFunction = AIFunctionFactory.Create(GetWeather);
AIFunction approvalRequiredWeatherFunction = new ApprovalRequiredAIFunction(weatherFunction);

Beim Erstellen des Agents können Sie jetzt dem Agenten ein Funktionstool bereitstellen, das eine Genehmigung erfordert, indem Sie eine Liste von Tools an die AsAIAgent-Methode übergeben.

AIAgent agent = new AIProjectClient(
    new Uri("<your-foundry-project-endpoint>"),
    new DefaultAzureCredential())
     .AsAIAgent(
        model: "gpt-4o-mini",
        instructions: "You are a helpful assistant",
        tools: [approvalRequiredWeatherFunction]);

Warnung

DefaultAzureCredential ist praktisch für die Entwicklung, erfordert aber sorgfältige Überlegungen in der Produktion. Berücksichtigen Sie in der Produktion die Verwendung bestimmter Anmeldeinformationen (z. B. ManagedIdentityCredential), um Latenzprobleme, unbeabsichtigte Abfragen von Anmeldeinformationen und potenzielle Sicherheitsrisiken durch Ausweichmechanismen zu vermeiden.

Da Sie jetzt über eine Funktion verfügen, die eine Genehmigung erfordert, antwortet der Agent möglicherweise mit einer Genehmigungsanforderung, anstatt die Funktion direkt auszuführen und das Ergebnis zurückzugeben. Sie können den Antwortinhalt für alle ToolApprovalRequestContent Instanzen überprüfen, was angibt, dass der Agent eine Benutzergenehmigung für eine Funktion erfordert.

AgentSession session = await agent.CreateSessionAsync();
AgentResponse response = await agent.RunAsync("What is the weather like in Amsterdam?", session);

var toolApprovalRequests = response.Messages
    .SelectMany(x => x.Contents)
    .OfType<ToolApprovalRequestContent>()
    .ToList();

Wenn Funktionsgenehmigungsanforderungen vorhanden sind, steht der Funktionsaufruf einschließlich name und Argumente in der ToolCall Eigenschaft der ToolApprovalRequestContent Instanz zur Verfügung. Dies kann dem Benutzer angezeigt werden, damit er entscheiden kann, ob der Funktionsaufruf genehmigt oder abgelehnt werden soll. Gehen Sie in diesem Beispiel davon aus, dass eine Anforderung vorhanden ist.

ToolApprovalRequestContent requestContent = toolApprovalRequests.First();
var functionCall = (FunctionCallContent)requestContent.ToolCall;
Console.WriteLine($"We require approval to execute '{functionCall.Name}'");

Nachdem der Benutzer seine Eingabe übermittelt hat, verwenden Sie die Methode CreateResponse auf ToolApprovalRequestContent, um die Genehmigungsantwort zu erstellen. Übergeben Sie true, um den Funktionsaufruf zu genehmigen, oder false, um ihn abzulehnen.

Der Antwortinhalt kann dann zusammen mit demselben Sitzungsobjekt an den Agenten UserChatMessage übergeben werden, um das Ergebnis vom Agenten zu erhalten.

var approvalMessage = new ChatMessage(ChatRole.User, [requestContent.CreateResponse(true)]);
Console.WriteLine(await agent.RunAsync(approvalMessage, session));

Wenn Sie Funktionstools mit menschlichen Genehmigungen im Prozess verwenden, denken Sie daran, nach jedem Agentenlauf nach ToolApprovalRequestContent-Instanzen in der Antwort zu suchen, bis alle Funktionsaufrufe genehmigt oder abgelehnt wurden.

Tip

Ein vollständiges, runnables Beispiel finden Sie unter .NET Agents Schritt 01: Verwenden von Funktionstools mit Genehmigungen .

In diesem Schritt des Tutorials erfahren Sie, wie Sie Funktionen verwenden, die eine menschliche Genehmigung durch einen Agenten erfordern.

Wenn Agents eine Benutzereingabe erfordern, z. B. zum Genehmigen eines Funktionsaufrufs, wird dies als "Human-in-the-Loop"-Muster bezeichnet. Ein Agentenlauf, der eine Benutzereingabe erfordert, liefert eine Antwort, die angibt, welche Eingabe vom Benutzer erforderlich ist, anstatt mit einer endgültigen Antwort abzuschließen. Der Anrufer des Agents ist dann dafür verantwortlich, die erforderlichen Eingaben vom Benutzer zu erhalten und sie im Rahmen eines neuen Agentendurchlaufs an den Agenten zurückzugeben.

Voraussetzungen

Die erforderlichen Komponenten und die Installation von Python-Paketen finden Sie im Abschnitt zum Erstellen und Ausführen eines einfachen Agent-Schritts in diesem Lernprogramm.

Erstellen des Agents mit Funktionstools, die eine Genehmigung erfordern

Bei der Verwendung von Funktionen ist es möglich, für jede Funktion anzugeben, ob sie eine menschliche Genehmigung erfordert, bevor sie ausgeführt wird. Dies geschieht durch Setzen des approval_mode Parameters auf "always_require", wenn der @tool Dekorator verwendet wird.

Hier ist ein Beispiel für ein einfaches Funktionstool, das das Wetter für einen bestimmten Ort fälscht.

from typing import Annotated
from agent_framework import tool

@tool
def get_weather(location: Annotated[str, "The city and state, e.g. San Francisco, CA"]) -> str:
    """Get the current weather for a given location."""
    return f"The weather in {location} is cloudy with a high of 15°C."

Um eine Funktion zu erstellen, die eine Genehmigung erfordert, können Sie den approval_mode Parameter verwenden:

@tool(approval_mode="always_require")
def get_weather_detail(location: Annotated[str, "The city and state, e.g. San Francisco, CA"]) -> str:
    """Get detailed weather information for a given location."""
    return f"The weather in {location} is cloudy with a high of 15°C, humidity 88%."

Beim Erstellen des Agents können Sie nun das Genehmigung erfordernde Funktionstool bereitstellen, indem Sie dem Agent-Konstruktor eine Liste von Tools übergeben.

from agent_framework import Agent
from agent_framework.openai import OpenAIChatClient

async with Agent(
    client=OpenAIChatClient(),
    name="WeatherAgent",
    instructions="You are a helpful weather assistant.",
    tools=[get_weather, get_weather_detail],
) as agent:
    # Agent is ready to use
    pass

Da Sie jetzt über eine Funktion verfügen, die eine Genehmigung erfordert, antwortet der Agent möglicherweise mit einer Genehmigungsanforderung, anstatt die Funktion direkt auszuführen und das Ergebnis zurückzugeben. Sie können die Antwort auf alle Benutzereingabeanforderungen überprüfen, was angibt, dass der Agent eine Benutzergenehmigung für eine Funktion erfordert.

session = agent.create_session()
result = await agent.run(
    "What is the detailed weather like in Amsterdam?",
    session=session,
)

if result.user_input_requests:
    for user_input_needed in result.user_input_requests:
        if user_input_needed.function_call is None:
            continue
        print(f"Function: {user_input_needed.function_call.name}")
        print(f"Arguments: {user_input_needed.function_call.arguments}")

Wenn Funktionsgenehmigungsanforderungen vorhanden sind, finden Sie die Details des Funktionsaufrufs einschließlich Name und Argumente in der function_call Eigenschaft für die Benutzereingabeanforderung. Dies kann dem Benutzer angezeigt werden, damit er entscheiden kann, ob der Funktionsaufruf genehmigt oder abgelehnt werden soll.

Nachdem der Benutzer seine Eingabe bereitgestellt hat, können Sie eine Antwort mithilfe der to_function_approval_response Methode für die Benutzereingabeanforderung erstellen. Übergeben Sie True, um den Funktionsaufruf zu genehmigen, oder False, um ihn abzulehnen.

Setzen Sie die Ausführung mit der Genehmigungsantwort und demselben AgentSession fort:

from agent_framework import Message

# Get user approval (in a real application, this would be interactive)
user_approval = True  # or False to reject

# Create the approval response
approval_message = Message(
    role="user",
    contents=[user_input_needed.to_function_approval_response(user_approval)]
)

# Continue the conversation with the approval
final_result = await agent.run(approval_message, session=session)
print(final_result.text)

Bearbeitung von Genehmigungen in einer Schleife

Wenn Sie mit mehreren Funktionsaufrufen arbeiten, die eine Genehmigung erfordern, müssen Sie möglicherweise Genehmigungen in einer Schleife verarbeiten, bis alle Funktionen genehmigt oder abgelehnt werden:

async def handle_approvals(query: str, agent) -> str:
    """Handle function call approvals in a loop."""
    session = agent.create_session()
    current_input = query

    while True:
        result = await agent.run(current_input, session=session)

        if not result.user_input_requests:
            # No more approvals needed, return the final result
            return result.text

        # Build the approval responses for the requests stored in the session.
        new_inputs = []

        for user_input_needed in result.user_input_requests:
            if user_input_needed.function_call is None:
                continue
            print(f"Approval needed for: {user_input_needed.function_call.name}")
            print(f"Arguments: {user_input_needed.function_call.arguments}")

            # Get user approval (in practice, this would be interactive)
            user_approval = True  # Replace with actual user input

            # Add the user's approval response
            new_inputs.append(
                Message(role="user", contents=[user_input_needed.to_function_approval_response(user_approval)])
            )

        # Continue with all the context
        current_input = new_inputs

# Usage
result_text = await handle_approvals("Get detailed weather for Seattle and Portland", agent)
print(result_text)

Wenn Sie Funktionswerkzeuge mit Genehmigungsfunktion verwenden, denken Sie daran, nach jedem Agentenlauf die Antwort auf Benutzereingabeanforderungen zu überprüfen, bis alle Funktionsaufrufe genehmigt oder abgelehnt wurden.

Important

Standardmäßig autorisiert eine lokale Genehmigungsantwort einen Tool-Aufruf nur, wenn sie mit einer ausstehenden Genehmigungsanforderung übereinstimmt, die in demselben AgentSession erfasst wurde. Das Framework ignoriert eine ungebundene Antwort und protokolliert eine Warnung. Legen Sie fest client.function_invocation_configuration["disable_approval_response_binding"] = True nur, wenn Ihre Anwendung eine gleichwertige Bindung erzwingt, bevor Nachrichten den Agent erreichen. Mit dieser Deaktivierung wird das vorherige ungebundene Verhalten wiederhergestellt und kann zulassen, dass eine erstellte oder wiedergegebene Antwort einen privilegierten Toolaufruf genehmigt.

Genehmigungs- und Sicherheits-Middleware unterstützen die konvertierten Python Parametertypen, die unter "Konvertierte Python Parametertypen verwenden" beschrieben sind. Wenn Middleware bereits genehmigte Argumente ändert, erstellt Agent Framework nur dann eine Ersetzungsgenehmigungsanforderung, wenn die geänderten Werte in JSON serialisiert und auf dieselben Werte neu überprüft werden können. Wenn dieser genaue Roundtrip nicht möglich ist, schlägt der Aufruf mit MiddlewareFailure im geschlossenen Zustand fehl, anstatt die Genehmigung erneut zu verwenden oder wiederholt eine andere Genehmigung anzufordern. Die Bindung bei Genehmigung verwendet exakt die unveränderlichen konvertierten Typen und Datums- oder Uhrzeitwerte ohne Zeitzone oder einen festen Offset. Benutzerdefinierte Unterklassen und andere Zeitzonenimplementierungen schlagen im geschlossenen Zustand fehl.

Vollständiges Beispiel

# Copyright (c) Microsoft. All rights reserved.

import asyncio
from random import randrange
from typing import TYPE_CHECKING, Annotated, Any

from agent_framework import Agent, AgentResponse, Message, tool
from agent_framework.openai import OpenAIChatClient

if TYPE_CHECKING:
    from agent_framework import AgentSession, SupportsAgentRun

"""
Demonstration of a tool with approvals.

This sample demonstrates using AI functions with user approval workflows.
It shows how to handle function call approvals without using threads.
"""

conditions = ["sunny", "cloudy", "raining", "snowing", "clear"]


# NOTE: approval_mode="never_require" is for sample brevity. Use "always_require" in production; see samples/02-agents/tools/function_tool_with_approval.py and samples/02-agents/tools/function_tool_with_approval_and_sessions.py.
@tool(approval_mode="never_require")
def get_weather(location: Annotated[str, "The city and state, e.g. San Francisco, CA"]) -> str:
    """Get the current weather for a given location."""
    # Simulate weather data
    return f"The weather in {location} is {conditions[randrange(0, len(conditions))]} and {randrange(-10, 30)}°C."


# Define a simple weather tool that requires approval
@tool(approval_mode="always_require")
def get_weather_detail(location: Annotated[str, "The city and state, e.g. San Francisco, CA"]) -> str:
    """Get the current weather for a given location."""
    # Simulate weather data
    return (
        f"The weather in {location} is {conditions[randrange(0, len(conditions))]} and {randrange(-10, 30)}°C, "
        "with a humidity of 88%. "
        f"Tomorrow will be {conditions[randrange(0, len(conditions))]} with a high of {randrange(-10, 30)}°C."
    )


async def handle_approvals(
    query: str,
    agent: "SupportsAgentRun",
    session: "AgentSession",
) -> AgentResponse:
    """Handle function call approvals with an authoritative session."""
    result = await agent.run(query, session=session)
    while len(result.user_input_requests) > 0:
        new_inputs: list[Any] = []

        for user_input_needed in result.user_input_requests:
            print(
                f"\nUser Input Request for function from {agent.name}:"
                f"\n  Function: {user_input_needed.function_call.name}"
                f"\n  Arguments: {user_input_needed.function_call.arguments}"
            )

            # Get user approval
            user_approval = await asyncio.to_thread(input, "\nApprove function call? (y/n): ")

            # Add the user's approval response
            new_inputs.append(
                Message("user", [user_input_needed.to_function_approval_response(user_approval.lower() == "y")])
            )

        result = await agent.run(new_inputs, session=session)

    return result


async def handle_approvals_streaming(
    query: str,
    agent: "SupportsAgentRun",
    session: "AgentSession",
) -> None:
    """Handle streaming function approvals with an authoritative session."""
    current_input: str | list[Any] = query
    has_user_input_requests = True
    while has_user_input_requests:
        has_user_input_requests = False
        user_input_requests: list[Any] = []

        # Stream the response
        async for chunk in agent.run(current_input, stream=True, session=session):
            if chunk.text:
                print(chunk.text, end="", flush=True)

            # Collect user input requests from the stream
            if chunk.user_input_requests:
                user_input_requests.extend(chunk.user_input_requests)

        if user_input_requests:
            has_user_input_requests = True
            new_inputs: list[Any] = []

            for user_input_needed in user_input_requests:
                print(
                    f"\n\nUser Input Request for function from {agent.name}:"
                    f"\n  Function: {user_input_needed.function_call.name}"
                    f"\n  Arguments: {user_input_needed.function_call.arguments}"
                )

                # Get user approval
                user_approval = await asyncio.to_thread(input, "\nApprove function call? (y/n): ")

                # Add the user's approval response
                new_inputs.append(
                    Message("user", [user_input_needed.to_function_approval_response(user_approval.lower() == "y")])
                )

            # Update input with all the context for next iteration
            current_input = new_inputs


async def run_weather_agent_with_approval(stream: bool) -> None:
    """Example showing AI function with approval requirement."""
    print(f"\n=== Weather Agent with Approval Required ({'Streaming' if stream else 'Non-Streaming'}) ===\n")

    async with Agent(
        client=OpenAIChatClient(),
        name="WeatherAgent",
        instructions=("You are a helpful weather assistant. Use the get_weather tool to provide weather information."),
        tools=[get_weather, get_weather_detail],
    ) as agent:
        session = agent.create_session()
        query = "Can you give me an update of the weather in LA and Portland and detailed weather for Seattle?"
        print(f"User: {query}")

        if stream:
            print(f"\n{agent.name}: ", end="", flush=True)
            await handle_approvals_streaming(query, agent, session)
            print()
        else:
            result = await handle_approvals(query, agent, session)
            print(f"\n{agent.name}: {result}\n")


async def main() -> None:
    print("=== Demonstration of a tool with approvals ===\n")

    await run_weather_agent_with_approval(stream=False)
    await run_weather_agent_with_approval(stream=True)


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

Toolgenehmigung

Sie können eine menschliche Bestätigung verlangen, bevor ein Tool ausgeführt wird, indem Sie es in tool.ApprovalRequiredFunc einschließen:

import "github.com/microsoft/agent-framework-go/tool"

approvedWeatherTool := tool.ApprovalRequiredFunc(weatherTool)

a := foundryprovider.NewAgent(endpoint, token, foundryprovider.ModelDeployment(model), foundryprovider.AgentConfig{
    Instructions: "You are a helpful assistant.",
    Config: agent.Config{
        Tools: []tool.Tool{approvedWeatherTool},
    },
})

Wenn das Modell ein genehmigungsrelevantes Tool anfordert, gibt der Agent message.ToolApprovalRequestContent zurück, anstatt es auszuführen. Der Host sammelt die Entscheidung des Benutzers und gibt die entsprechende Antwort zurück.

Freigaben in einer Schleife bearbeiten

Erstellen Sie eine agent.Session und verwenden Sie diese für den ersten Prompt und jede Bestätigungsantwort. Prüfen Sie response.Contents() auf Genehmigungsanforderungen, fragen Sie den Benutzer, und rufen Sie request.CreateResponse(approved, "") mit der Entscheidung auf.

Senden Sie den Antwortinhalt über a.RunMessage und fahren Sie fort, bis keine Genehmigungsanforderungen verbleiben. Geben Sie Ablehnungen sowie Genehmigungen zurück, damit das Modell auf die Entscheidung des Benutzers reagieren kann.

Die folgende Beispielfunktion implementiert diese Schleife:

func runPrompt(ctx context.Context, a *agent.Agent, session *agent.Session, prompt string) error {
    response, err := a.RunText(ctx, prompt, agent.WithSession(session)).Collect()
    for {
        if err != nil {
            return err
        }
        demo.Response(response, nil)
        var approvals []message.Content
        for content := range response.Contents() {
            if request, ok := content.(*message.ToolApprovalRequestContent); ok {
                approvals = append(approvals, request.CreateResponse(demo.UserInputRequest(request), ""))
            }
        }
        if len(approvals) == 0 {
            return nil
        }
        response, err = a.RunMessage(ctx, message.New(approvals...), agent.WithSession(session)).Collect()
    }
}

Die Funktion akzeptiert einen konfigurierten Agent, eine Sitzung und eine Eingabeaufforderung. Die demo.UserInputRequest des Beispiels sammelt Terminaleingaben. Ersetzen Sie diese UI-Interaktion in Ihrem eigenen Host. Diese Antwortschleife funktioniert auch mit einem einfachen, anbietergestützten Agent mit genehmigungspflichtigen Tools.

Sehen Sie sich das vollständige Beispiel zur Genehmigung von Funktions-Tools für die Tooleinrichtung und das Composite-Harness-Beispiel für die vollständige Schleife und Importe an.

Tool-Genehmigung mit Harness Agent verwenden

Einfache/manuelle Komposition erfordert ein genehmigungsmarkiertes Tool und eine Genehmigungsantwortschleife. Ein Harness Agent verwendet dieselben zur Genehmigung markierten Tools und Antwortinhalte, installiert aber auch Middleware für Anfragen in der Warteschlange, dauerhafte „Immer genehmigen“-Regeln und eine optionale heuristische Auto-Genehmigung.

Umschließen Sie Funktionen, die eine Genehmigung erfordern, mit ApprovalRequiredAIFunction, und fügen Sie sie dann über HarnessAgentOptions.ChatOptions.Tools hinzu:

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

var weatherTool = new ApprovalRequiredAIFunction(
    AIFunctionFactory.Create(GetWeather));

AIAgent agent = chatClient.AsHarnessAgent(new HarnessAgentOptions
{
    ChatOptions = new ChatOptions
    {
        Instructions = "You are a helpful assistant.",
        Tools = [weatherTool],
    },
});

AgentSession session = await agent.CreateSessionAsync();
AgentResponse response = await agent.RunAsync(
    "What is the weather like in Amsterdam?",
    session);

DisableToolAutoApproval ist standardmäßig false, daher fügt das Harness ToolApprovalAgent hinzu. Mit der Standardeinstellung ToolApprovalAgentOptionswerden keine heuristischen Regeln konfiguriert. Nicht übereinstimmende ToolApprovalRequestContent Elemente werden weiterhin zur Genehmigung an den Aufrufer zurückgegeben. Um vertrauenswürdige Rückrufe für die automatische Genehmigung hinzuzufügen, legen Sie folgendes fest ToolApprovalAgentOptions.AutoApprovalRules.

Durch das Festlegen von DisableToolAutoApproval = true wird nur die Middleware zur automatischen Genehmigung auf Basis von Dauerregeln, Warteschlangen und Heuristiken entfernt. Dadurch wird die Genehmigungspflicht für ein ApprovalRequiredAIFunction nicht aufgehoben. Genehmigungsantwortbindung und Umgehung von Tools, die keine Genehmigung erfordern, bleiben ebenfalls standardmäßig aktiviert; ihre separaten Opt-Outs sind DisableApprovalResponseBinding und DisableApprovalNotRequiredFunctionBypassing.

Markieren Sie das Tool mit approval_mode="always_require" und übergeben Sie es an create_harness_agent:

from agent_framework import create_harness_agent, tool

@tool(approval_mode="always_require")
def get_weather_detail(location: str) -> str:
    """Get detailed weather information for a location."""
    return f"The weather in {location} is cloudy with a high of 15°C."

agent = create_harness_agent(
    client=client,
    agent_instructions="You are a helpful weather assistant.",
    tools=get_weather_detail,
)

session = agent.create_session()
result = await agent.run(
    "What is the detailed weather like in Amsterdam?",
    session=session,
)

disable_tool_auto_approval=False fügt standardmäßig hinzu ToolApprovalMiddleware . Die Middleware benötigt dasselbe AgentSession über mehrere Genehmigungszyklen hinweg, reiht mehrere Anfragen in die Warteschlange ein, wendet bereits vorliegende Genehmigungen aus früheren Antworten des Benutzers an und wertet auto_approval_rules aus, bevor sie eine Anfrage an den Aufrufer zurückgibt. Mit auto_approval_rules=None genehmigt kein heuristischer Rückruf einen Anruf automatisch.

Dauergenehmigungen bleiben im AgentSession Zustand. Sie sind nicht an die Agent- oder Toolinstanz gebunden, die sie erstellt hat. Ein Ersatztool mit demselben Namen, einschließlich eines MCP-Tools, kann mit einer gespeicherten toolweiten oder argumentspezifischen Regel übereinstimmen. Sitzungen auf eine stabile Vertrauensgrenze beschränken. Überprüfen Sie gespeicherte Regeln, wenn sich der Agent oder das Toolset ändert, und starten Sie eine neue Sitzung, wenn eine Genehmigung nicht fortgelten soll.

Durch das Setzen von disable_tool_auto_approval=True wird diese Harness-Middleware entfernt, aber die approval_mode des Tools wird dadurch nicht geändert; der normale result.user_input_requests-Freigabeprozess gilt weiterhin.

Verwenden Sie für lokale MCP-Tools eine bestimmte approval_mode Zuordnung, wenn benannte Tools unterschiedliche Richtlinien benötigen. Legen Sie den default auf "always_require" oder "never_require" fest, damit neu ermittelte, nicht aufgelistete Tools eine explizite Richtlinie haben. Siehe Werkzeuge nach eindeutigem Namen auswählen.

Das Go-Hilfsprogramm harness.AgentConfig fügt agent/harness/toolapproval Middleware mit aktivierten stehenden Genehmigungen und automatischen Genehmigungsregeln hinzu. Konfigurieren Sie sie über harness.Config.ToolApproval, oder legen Sie DisableToolApproval fest, um diese Middleware wegzulassen.

Tools müssen weiterhin ihre Genehmigungsanforderungen deklarieren, z. B. mit tool.ApprovalRequiredFunc. Durch das Deaktivieren der Middleware für die Harness-Genehmigung werden diese Anforderungen nicht entfernt. Der Host muss offene Genehmigungsanfragen verarbeiten und die entsprechenden Antworten in derselben Sitzung zurückgeben.

Eine Genehmigungsantwortschleife finden Sie im Beispiel für zusammengesetzte Umgebungen.

Nächste Schritte

Codedolmetscher