Microsoft Agent Framework-munkafolyamatok vezénylése – Átadás

Az átadás vezérlés lehetővé teszi, hogy az ügynökök a környezet vagy a felhasználói kérés alapján átadják az irányítást egymásnak. Minden ügynök "átadhatja" a beszélgetést egy másik ügynöknek a megfelelő szakértelemmel, biztosítva, hogy a megfelelő ügynök kezelje a feladat egyes részeit. Ez különösen hasznos az ügyfélszolgálat, a szakértői rendszerek vagy bármely dinamikus delegálást igénylő forgatókönyv esetében.

A handoff vezénylés belsőleg egy mesh topológiával valósul meg, ahol az ügynökök közvetlenül, vezénylő nélkül csatlakoznak egymáshoz. Minden ügynök eldöntheti, hogy mikor adja le a beszélgetést előre meghatározott szabályok vagy az üzenetek tartalma alapján.

Megjegyzés:

A handoff vezénylés csak Agent támogatását biztosítja, és az ügynököknek támogatniuk kell a helyi eszközök futtatását.

A handoff és az ügynök mint eszköz közötti különbségek

Noha az ügynök mint eszköz mintát gyakran többügynök-mintának tekintik, és első ránézésre hasonlónak tűnhet a továbbadáshoz, alapvető különbségek vannak a kettő között.

• Vezérlési folyamat: Az átadási vezénylés során a rendszer explicit módon továbbítja a vezérlést az ügynökök között a meghatározott szabályok alapján. Minden ügynök dönthet úgy, hogy a teljes feladatot átadja egy másik ügynöknek. Nincs központi hatóság, amely felügyeli a munkafolyamatot. Ezzel szemben az "ügynök mint eszköz" stratégia egy elsődleges ügynökből áll, amely részfeladatokat delegál más ügynököknek, és amint egy ügynök befejezi a részfeladatot, a vezérlés visszatér az elsődleges ügynökhöz.
• Feladat tulajdonjoga: Az átadáskor az átadást fogadó ügynök teljes mértékben átveszi a feladat tulajdonjogát. Az ügynöki eszközökben az elsődleges ügynök továbbra is teljes felelősséget vállal a feladatért, míg más ügynököket az adott altevékenységek segítésére szolgáló eszközökként kezelnek.
• Környezetkezelés: Az átadási folyamat során a beszélgetést teljes egészében egy másik ügynöknek adják át. A fogadó ügynök teljes körűen tisztában van az eddig elvégzett tevékenységekkel. Az ügynökkénti eszközökben az elsődleges ügynök kezeli a teljes környezetet, és szükség szerint csak releváns információkat adhat meg az eszközügynököknek.

Tudnivalók

• Speciális ügynökök létrehozása különböző tartományokhoz
• Átadási szabályok konfigurálása ügynökök között
• Interaktív munkafolyamatok létrehozása dinamikus ügynök-útválasztással
• Többfordulós beszélgetések kezelése ügynökváltással
• Eszközjóváhagyás megvalósítása bizalmas műveletekhez (HITL)
• Ellenőrzőpontok használata tartós átadási munkafolyamatokhoz

Az átadási vezénylés során az ügynökök a környezet alapján átadhatják az irányítást egymásnak, lehetővé téve a dinamikus útválasztást és a speciális szakértelem kezelését.

Az Azure OpenAI-ügyfél beállítása

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Azure.AI.OpenAI;
using Azure.Identity;
using Microsoft.Agents.AI.Workflows;
using Microsoft.Extensions.AI;
using Microsoft.Agents.AI;

// 1) Set up the Azure OpenAI client
var endpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT") ??
    throw new InvalidOperationException("AZURE_OPENAI_ENDPOINT is not set.");
var deploymentName = Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOYMENT_NAME") ?? "gpt-4o-mini";
var client = new AzureOpenAIClient(new Uri(endpoint), new DefaultAzureCredential())
    .GetChatClient(deploymentName)
    .AsIChatClient();

Figyelmeztetés

DefaultAzureCredential a fejlesztéshez kényelmes, de a termelési környezetben gondos megfontolást igényel. Éles környezetben fontolja meg egy adott hitelesítő adat (pl. ManagedIdentityCredential) használatát a késési problémák elkerülése, a hitelesítő adatok nem szándékos próbálgatásának és a tartalék mechanizmusokból eredő esetleges biztonsági kockázatok elkerülése érdekében.

A specializált ügynökök definiálása

Hozzon létre tartományspecifikus ügynököket és egy triage ügynököt az útválasztáshoz:

// 2) Create specialized agents
ChatClientAgent historyTutor = new(client,
    "You provide assistance with historical queries. Explain important events and context clearly. Only respond about history.",
    "history_tutor",
    "Specialist agent for historical questions");

ChatClientAgent mathTutor = new(client,
    "You provide help with math problems. Explain your reasoning at each step and include examples. Only respond about math.",
    "math_tutor",
    "Specialist agent for math questions");

ChatClientAgent triageAgent = new(client,
    "You determine which agent to use based on the user's homework question. ALWAYS handoff to another agent.",
    "triage_agent",
    "Routes messages to the appropriate specialist agent");

Átadási szabályok konfigurálása

Adja meg, hogy mely ügynökök adhatják át más ügynököknek a következőket:

// 3) Build handoff workflow with routing rules
var workflow = AgentWorkflowBuilder.StartHandoffWith(triageAgent)
    .WithHandoffs(triageAgent, [mathTutor, historyTutor]) // Triage can route to either specialist
    .WithHandoff(mathTutor, triageAgent)                  // Math tutor can return to triage
    .WithHandoff(historyTutor, triageAgent)               // History tutor can return to triage
    .Build();

Interaktív átadási munkafolyamat futtatása

Többfordulós beszélgetések kezelése dinamikus ügynökváltással:

// 4) Process multi-turn conversations
List<ChatMessage> messages = new();

while (true)
{
    Console.Write("Q: ");
    string userInput = Console.ReadLine()!;
    messages.Add(new(ChatRole.User, userInput));

    // Execute workflow and process events
    StreamingRun run = await InProcessExecution.StreamAsync(workflow, messages);
    await run.TrySendMessageAsync(new TurnToken(emitEvents: true));

    List<ChatMessage> newMessages = new();
    await foreach (WorkflowEvent evt in run.WatchStreamAsync().ConfigureAwait(false))
    {
        if (evt is AgentResponseUpdateEvent e)
        {
            Console.WriteLine($"{e.ExecutorId}: {e.Data}");
        }
        else if (evt is WorkflowOutputEvent outputEvt)
        {
            newMessages = (List<ChatMessage>)outputEvt.Data!;
            break;
        }
    }

    // Add new messages to conversation history
    messages.AddRange(newMessages.Skip(messages.Count));
}

Minta interakció

Q: What is the derivative of x^2?
triage_agent: This is a math question. I'll hand this off to the math tutor.
math_tutor: The derivative of x^2 is 2x. Using the power rule, we bring down the exponent (2) and multiply it by the coefficient (1), then reduce the exponent by 1: d/dx(x^2) = 2x^(2-1) = 2x.

Q: Tell me about World War 2
triage_agent: This is a history question. I'll hand this off to the history tutor.
history_tutor: World War 2 was a global conflict from 1939 to 1945. It began when Germany invaded Poland and involved most of the world's nations. Key events included the Holocaust, Pearl Harbor attack, D-Day invasion, and ended with atomic bombs on Japan.

Q: Can you help me with calculus integration?
triage_agent: This is another math question. I'll route this to the math tutor.
math_tutor: I'd be happy to help with calculus integration! Integration is the reverse of differentiation. The basic power rule for integration is: ∫x^n dx = x^(n+1)/(n+1) + C, where C is the constant of integration.

Néhány eszköz definiálása a bemutatóhoz

@tool
def process_refund(order_number: Annotated[str, "Order number to process refund for"]) -> str:
    """Simulated function to process a refund for a given order number."""
    return f"Refund processed successfully for order {order_number}."

@tool
def check_order_status(order_number: Annotated[str, "Order number to check status for"]) -> str:
    """Simulated function to check the status of a given order number."""
    return f"Order {order_number} is currently being processed and will ship in 2 business days."

@tool
def process_return(order_number: Annotated[str, "Order number to process return for"]) -> str:
    """Simulated function to process a return for a given order number."""
    return f"Return initiated successfully for order {order_number}. You will receive return instructions via email."

A csevegőügyfél beállítása

from agent_framework.azure import AzureOpenAIChatClient
from azure.identity import AzureCliCredential

# Initialize the Azure OpenAI chat client
chat_client = AzureOpenAIChatClient(credential=AzureCliCredential())

A specializált ügynökök definiálása

Hozzon létre tartományspecifikus ügynököket egy koordinátorral az útválasztáshoz:

# Create triage/coordinator agent
triage_agent = chat_client.as_agent(
    instructions=(
        "You are frontline support triage. Route customer issues to the appropriate specialist agents "
        "based on the problem described."
    ),
    description="Triage agent that handles general inquiries.",
    name="triage_agent",
)

# Refund specialist: Handles refund requests
refund_agent = chat_client.as_agent(
    instructions="You process refund requests.",
    description="Agent that handles refund requests.",
    name="refund_agent",
    # In a real application, an agent can have multiple tools; here we keep it simple
    tools=[process_refund],
)

# Order/shipping specialist: Resolves delivery issues
order_agent = chat_client.as_agent(
    instructions="You handle order and shipping inquiries.",
    description="Agent that handles order tracking and shipping issues.",
    name="order_agent",
    # In a real application, an agent can have multiple tools; here we keep it simple
    tools=[check_order_status],
)

# Return specialist: Handles return requests
return_agent = chat_client.as_agent(
    instructions="You manage product return requests.",
    description="Agent that handles return processing.",
    name="return_agent",
    # In a real application, an agent can have multiple tools; here we keep it simple
    tools=[process_return],
)

Átadási szabályok konfigurálása

Hozza létre az átadási munkafolyamatot a következővel HandoffBuilder:

from agent_framework.orchestrations import HandoffBuilder

# Build the handoff workflow
workflow = (
    HandoffBuilder(
        name="customer_support_handoff",
        participants=[triage_agent, refund_agent, order_agent, return_agent],
        termination_condition=lambda conversation: len(conversation) > 0 and "welcome" in conversation[-1].text.lower(),
    )
    .with_start_agent(triage_agent) # Triage receives initial user input
    .build()
)

Alapértelmezés szerint minden ügynök átadhatja a munkát egymásnak. A speciálisabb útválasztáshoz konfigurálhatja az átadásokat:

workflow = (
    HandoffBuilder(
        name="customer_support_handoff",
        participants=[triage_agent, refund_agent, order_agent, return_agent],
        termination_condition=lambda conversation: len(conversation) > 0 and "welcome" in conversation[-1].text.lower(),
    )
    .with_start_agent(triage_agent) # Triage receives initial user input
    # Triage cannot route directly to refund agent
    .add_handoff(triage_agent, [order_agent, return_agent])
    # Only the return agent can handoff to refund agent - users wanting refunds after returns
    .add_handoff(return_agent, [refund_agent])
    # All specialists can handoff back to triage for further routing
    .add_handoff(order_agent, [triage_agent])
    .add_handoff(return_agent, [triage_agent])
    .add_handoff(refund_agent, [triage_agent])
    .build()
)

Megjegyzés:

Még egyéni átadási szabályok esetén is minden ügynök továbbra is egy hálótopológiában csatlakozik. Ennek az az oka, hogy az ügynököknek meg kell osztaniuk a kontextust egymással a beszélgetési előzmények fenntartásához (további részletekért lásd a Környezetszinkronizálást ). Az átadási szabályok csak azt szabályozzák, hogy mely ügynökök vehetik át a következő beszélgetést.

Handoff Agent interakció futtatása

A többi orchestrationtól eltérően interaktív az átadás folyamata, mert előfordulhat, hogy egy ügynök nem dönt úgy, hogy minden sor után átad. Ha egy ügynök nem adja le, emberi bemenetre van szükség a beszélgetés folytatásához. A követelmény megkerüléséhez tekintse meg az autonóm módot . Más vezénylésekben az ügynök válasza után a vezérlés vagy a vezénylőhöz, vagy a következő ügynökhöz kerül.

Ha egy ügynök egy átadási munkafolyamatban úgy dönt, hogy nem adja át a feladatot (ezt egy speciális eszközhívás aktiválja), a munkafolyamat kibocsát egy WorkflowEvent elemet a type="request_info" keretében, amely tartalmazza az ügynök legutóbbi üzeneteit a HandoffAgentUserRequest részben. A felhasználónak válaszolnia kell erre a kérésre a munkafolyamat folytatásához.

from agent_framework import WorkflowEvent
from agent_framework.orchestrations import HandoffAgentUserRequest

# Start workflow with initial user message
events = [event async for event in workflow.run_stream("I need help with my order")]

# Process events and collect pending input requests
pending_requests = []
for event in events:
    if event.type == "request_info" and isinstance(event.data, HandoffAgentUserRequest):
        pending_requests.append(event)
        request_data = event.data
        print(f"Agent {event.executor_id} is awaiting your input")
        # The request contains the most recent messages generated by the
        # agent requesting input
        for msg in request_data.agent_response.messages[-3:]:
            print(f"{msg.author_name}: {msg.text}")

# Interactive loop: respond to requests
while pending_requests:
    user_input = input("You: ")

    # Send responses to all pending requests
    responses = {req.request_id: HandoffAgentUserRequest.create_response(user_input) for req in pending_requests}
    # You can also send a `HandoffAgentUserRequest.terminate()` to end the workflow early
    events = [event async for event in workflow.run(responses=responses)]

    # Process new events
    pending_requests = []
    for event in events:
        # Check for new input requests

Autonóm mód

A Handoff forgatókönyv olyan interaktív helyzetekhez készült, ahol emberi bemenetre van szükség, amikor egy ügynök úgy dönt, hogy nem végzi el az átadást. Kísérleti funkcióként azonban engedélyezheti az "autonóm módot", amely lehetővé teszi a munkafolyamat emberi beavatkozás nélküli folytatását. Ebben a módban, amikor egy ügynök úgy dönt, hogy nem ad át, a munkafolyamat automatikusan küld egy alapértelmezett választ (példáulUser did not respond. Continue assisting autonomously.) az ügynöknek, így folytathatja a beszélgetést.

Jótanács

Miért interaktív a Handoff orkesztráció? A többi vezényléstől eltérően, ahol az ügynök válasza után csak egy utat kell követnie (például vissza a vezénylőhöz vagy a következő ügynökhöz), a Handoff vezénylésben az ügynöknek lehetősége van arra, hogy átadjon egy másik ügynököt, vagy továbbra is segítse a felhasználót. Mivel az átadások eszközhívásokkal érhetők el, ha egy ügynök nem hív meg egy átadási eszközt, hanem választ hoz létre, a munkafolyamat nem tudja, hogy mi a következő lépés, hanem vissza kell delegálni a felhasználónak a további bemenethez. Az sem lehetséges, hogy az ügynököt kényszerítsük arra, hogy mindig használja az átadási eszközt, mert az ügynök máskülönben nem tud érdemi válaszokat generálni.

Az autonóm mód a with_autonomous_mode() hívásával kapcsolható be a HandoffBuilder. Ez úgy konfigurálja a munkafolyamatot, hogy automatikusan válaszoljon a bemeneti kérelmekre egy alapértelmezett üzenettel, így az ügynök anélkül folytathatja a munkát, hogy emberi bemenetre vár.

workflow = (
    HandoffBuilder(
        name="autonomous_customer_support",
        participants=[triage_agent, refund_agent, order_agent, return_agent],
    )
    .with_start_agent(triage_agent)
    .with_autonomous_mode()
    .build()
)

Az önálló üzemmódot az ügynökök egy részhalmazán is engedélyezheti az ügynökpéldányok with_autonomous_mode()listájának átadásával.

workflow = (
    HandoffBuilder(
        name="partially_autonomous_support",
        participants=[triage_agent, refund_agent, order_agent, return_agent],
    )
    .with_start_agent(triage_agent)
    .with_autonomous_mode(agents=[triage_agent])  # Only triage_agent runs autonomously
    .build()
)

Testre szabhatja az alapértelmezett válaszüzenetet.

workflow = (
    HandoffBuilder(
        name="custom_autonomous_support",
        participants=[triage_agent, refund_agent, order_agent, return_agent],
    )
    .with_start_agent(triage_agent)
    .with_autonomous_mode(
        agents=[triage_agent],
        prompts={triage_agent.name: "Continue with your best judgment as the user is unavailable."},
    )
    .build()
)

Testre szabhatja, hogy egy ügynök hány fordulót futtathat önállóan, mielőtt emberi bemenetre van szükség. Ez megakadályozhatja, hogy a munkafolyamat határozatlan ideig fusson felhasználói beavatkozás nélkül.

workflow = (
    HandoffBuilder(
        name="limited_autonomous_support",
        participants=[triage_agent, refund_agent, order_agent, return_agent],
    )
    .with_start_agent(triage_agent)
    .with_autonomous_mode(
        agents=[triage_agent],
        turn_limits={triage_agent.name: 3},  # Max 3 autonomous turns
    )
    .build()
)

Haladó: Eszközjóváhagyás az átadás munkafolyamatában

Az átadási munkafolyamatok olyan ügynököket is tartalmazhatnak, amelyek végrehajtásához emberi jóváhagyásra van szükség. Ez olyan érzékeny műveletek esetén hasznos, mint a visszatérítések feldolgozása, a vásárlások lebonyolítása vagy a visszavonhatatlan műveletek végrehajtása.

Eszközök definiálása jóváhagyás szükséges

from typing import Annotated
from agent_framework import tool

@tool(approval_mode="always_require")
def process_refund(order_number: Annotated[str, "Order number to process refund for"]) -> str:
    """Simulated function to process a refund for a given order number."""
    return f"Refund processed successfully for order {order_number}."

Ügynökök létrehozása jóváhagyást igénylő eszközökkel

from agent_framework import Agent
from agent_framework.azure import AzureOpenAIChatClient
from azure.identity import AzureCliCredential

client = AzureOpenAIChatClient(credential=AzureCliCredential())

triage_agent = chat_client.as_agent(
    instructions=(
        "You are frontline support triage. Route customer issues to the appropriate specialist agents "
        "based on the problem described."
    ),
    description="Triage agent that handles general inquiries.",
    name="triage_agent",
)

refund_agent = chat_client.as_agent(
    instructions="You process refund requests.",
    description="Agent that handles refund requests.",
    name="refund_agent",
    tools=[process_refund],
)

order_agent = chat_client.as_agent(
    instructions="You handle order and shipping inquiries.",
    description="Agent that handles order tracking and shipping issues.",
    name="order_agent",
    tools=[check_order_status],
)

Felhasználói beviteli és eszköz-jóváhagyási kérések kezelése

from agent_framework import (
    FunctionApprovalRequestContent,
    WorkflowEvent,
)
from agent_framework.orchestrations import HandoffBuilder, HandoffAgentUserRequest

workflow = (
    HandoffBuilder(
        name="support_with_approvals",
        participants=[triage_agent, refund_agent, order_agent],
    )
    .with_start_agent(triage_agent)
    .build()
)

pending_requests: list[WorkflowEvent] = []

# Start workflow
async for event in workflow.run_stream("My order 12345 arrived damaged. I need a refund."):
    if event.type == "request_info":
        pending_requests.append(event)

# Process pending requests - could be user input OR tool approval
while pending_requests:
    responses: dict[str, object] = {}

    for request in pending_requests:
        if isinstance(request.data, HandoffAgentUserRequest):
            # Agent needs user input
            print(f"Agent {request.executor_id} asks:")
            for msg in request.data.agent_response.messages[-2:]:
                print(f"  {msg.author_name}: {msg.text}")

            user_input = input("You: ")
            responses[request.request_id] = HandoffAgentUserRequest.create_response(user_input)

        elif isinstance(request.data, FunctionApprovalRequestContent):
            # Agent wants to call a tool that requires approval
            func_call = request.data.function_call
            args = func_call.parse_arguments() or {}

            print(f"\nTool approval requested: {func_call.name}")
            print(f"Arguments: {args}")

            approval = input("Approve? (y/n): ").strip().lower() == "y"
            responses[request.request_id] = request.data.create_response(approved=approval)

    # Send all responses and collect new requests
    pending_requests = []
    async for event in workflow.run(responses=responses):
        if event.type == "request_info":
            pending_requests.append(event)
        elif event.type == "output":
            print("\nWorkflow completed!")

Ellenőrzőpontokkal tartós munkafolyamatokhoz

Olyan hosszú ideig futó munkafolyamatok esetén, ahol az eszközök jóváhagyása órákkal vagy napokkal később is megtörténhet, használja az ellenőrzőpont-készítést:

from agent_framework import FileCheckpointStorage

storage = FileCheckpointStorage(storage_path="./checkpoints")

workflow = (
    HandoffBuilder(
        name="durable_support",
        participants=[triage_agent, refund_agent, order_agent],
        checkpoint_storage=storage,
    )
    .with_start_agent(triage_agent)
    .build()
)

# Initial run - workflow pauses when approval is needed
pending_requests = []
async for event in workflow.run_stream("I need a refund for order 12345"):
    if event.type == "request_info":
        pending_requests.append(event)

# Process can exit here - checkpoint is saved automatically

# Later: Resume from checkpoint and provide approval
checkpoints = await storage.list_checkpoints()
latest = sorted(checkpoints, key=lambda c: c.timestamp, reverse=True)[0]

# Step 1: Restore checkpoint to reload pending requests
restored_requests = []
async for event in workflow.run_stream(checkpoint_id=latest.checkpoint_id):
    if event.type == "request_info":
        restored_requests.append(event)

# Step 2: Send responses
responses = {}
for req in restored_requests:
    if isinstance(req.data, FunctionApprovalRequestContent):
        responses[req.request_id] = req.data.create_response(approved=True)
    elif isinstance(req.data, HandoffAgentUserRequest):
        responses[req.request_id] = HandoffAgentUserRequest.create_response("Yes, please process the refund.")

async for event in workflow.run(responses=responses):
    if event.type == "output":
        print("Refund workflow completed!")

Minta interakció

User: I need help with my order

triage_agent: I'd be happy to help you with your order. Could you please provide more details about the issue?

User: My order 1234 arrived damaged

triage_agent: I'm sorry to hear that your order arrived damaged. I will connect you with a specialist.

support_agent: I'm sorry about the damaged order. To assist you better, could you please:
- Describe the damage
- Would you prefer a replacement or refund?

User: I'd like a refund

triage_agent: I'll connect you with the refund specialist.

refund_agent: I'll process your refund for order 1234. Here's what will happen next:
1. Verification of the damaged items
2. Refund request submission
3. Return instructions if needed
4. Refund processing within 5-10 business days

Could you provide photos of the damage to expedite the process?

Környezetszinkronizálás

Az Ügynök-keretrendszerben az ügynökök az ügynöki munkamenetekre (AgentSession) támaszkodnak a környezet kezeléséhez. Handoff orkesztráció esetén az ügynökök nem osztják meg ugyanazt a munkamenetet, a résztvevők felelősek a kontextus konzisztenciájának biztosításáért. Ennek érdekében a résztvevők úgy vannak kialakítva, hogy a munkafolyamat összes többi résztvevője számára küldött válaszaikat vagy felhasználói bemeneteiket minden alkalommal továbbítsák, amikor választ hoznak létre, biztosítva, hogy minden résztvevő a legújabb környezettel rendelkezzen a következő fordulóhoz.

Megjegyzés:

Az eszközhöz kapcsolódó tartalmak, beleértve az átadási eszköz hívásait, nem lesznek továbbítva más ügynököknek. A rendszer csak a felhasználói és ügynöküzeneteket szinkronizálja az összes résztvevő között.

Jótanács

Az ügynökök nem osztják meg ugyanazt a munkamenet-példányt, mert a különböző ügynöktípusok eltérő implementációval rendelkezhetnek az AgentSession absztrakcióhoz. Ha ugyanazt a munkamenet-példányt osztja meg, az inkonzisztenciát okozhat abban, hogy az egyes ügynökök hogyan dolgoznak fel és tartanak fenn kontextust.

A válasz elküldése után a résztvevő ellenőrzi, hogy egy másik ügynöknek kell-e átadnia a beszélgetést. Ha igen, kérést küld a kijelölt ügynöknek, hogy vegye át a beszélgetést. Ellenkező esetben felhasználói bemenetet kér, vagy a munkafolyamat konfigurációja alapján autonóm módon folytatja.

Alapfogalmak

• Dinamikus útválasztás: Az ügynökök eldönthetik, hogy melyik ügynök kezelje a következő interakciót a környezet alapján
• AgentWorkflowBuilder.StartHandoffWith(): Meghatározza a munkafolyamatot elindító kezdeti ügynököt
• WithHandoff() és WithHandoffs(): Az átadási szabályok konfigurálása adott ügynökök között
• Konteksztus megőrzése: A teljes beszélgetési előzmény minden átadáson megmarad
• Többfordulós támogatás: Támogatja a folyamatos beszélgetéseket a zökkenőmentes ügynökváltással
• Specializált szakértelem: Minden ügynök a saját tartományára összpontosít, miközben az átadásokkal együttműködik

• Dinamikus útválasztás: Az ügynökök eldönthetik, hogy melyik ügynök kezelje a következő interakciót a környezet alapján
• HandoffBuilder: Munkafolyamatok létrehozása automatikus átadási eszközregisztrációval
• with_start_agent(): Meghatározza, hogy melyik ügynök kapja meg először a felhasználói bemenetet
• add_handoff(): Az ügynökök közötti konkrét átadási kapcsolatokat konfigurálja
• Konteksztus megőrzése: A teljes beszélgetési előzmény minden átadáson megmarad
• Kérelem/válaszciklus: A munkafolyamat felhasználói bemenetet kér, feldolgozza a válaszokat, és a befejezési feltétel teljesüléséig folytatódik
• Eszközjóváhagyás: Olyan bizalmas műveletekhez használható @tool(approval_mode="always_require") , amelyekhez emberi jóváhagyásra van szükség
• FunctionApprovalRequestContent: Ki van adva, amikor egy ügynök jóváhagyást igénylő eszközt hív meg; a válaszhoz create_response(approved=...)
• Ellenőrzőpontozás: Tartós munkafolyamatokhoz használható with_checkpointing() , amelyek a folyamat újraindítása során szüneteltethetők és folytathatók
• Specializált szakértelem: Minden ügynök a saját tartományára összpontosít, miközben az átadásokkal együttműködik

Következő lépések

Csoportos beszélgetés irányítása