Orkestrasi Alur Kerja Kerangka Kerja Agen Microsoft - Handoff

Orkestrasi handoff memungkinkan agen untuk mentransfer kontrol satu sama lain berdasarkan konteks atau permintaan pengguna. Setiap agen dapat "menyerahkan" percakapan ke agen lain dengan keahlian yang sesuai, memastikan bahwa agen yang tepat menangani setiap bagian tugas. Ini sangat berguna dalam dukungan pelanggan, sistem ahli, atau skenario apa pun yang memerlukan delegasi dinamis.

Secara internal, orkestrasi handoff diimplementasikan menggunakan topologi jala di mana agen terhubung langsung tanpa orkestrator. Setiap agen dapat memutuskan kapan harus menyerahkan percakapan berdasarkan aturan yang telah ditentukan sebelumnya atau konten pesan.

Nota

Orkestrasi handoff hanya mendukung Agent dan agen harus mendukung eksekusi alat lokal.

Perbedaan Antara Handoff dan Agent-as-Tools

Meskipun agen sebagai alat umumnya dianggap sebagai pola multi-agen dan mungkin terlihat mirip dengan sekilas, ada perbedaan mendasar antara keduanya:

• Alur Kontrol: Dalam orkestrasi handoff, kontrol secara eksplisit diteruskan antar agen berdasarkan aturan yang ditentukan. Setiap agen dapat memutuskan untuk menyerahkan seluruh tugas ke agen lain. Tidak ada otoritas pusat yang mengelola alur kerja. Sebaliknya, agen sebagai alat melibatkan agen utama yang mendelegasikan sub tugas ke agen lain dan setelah agen menyelesaikan sub tugas, kontrol kembali ke agen utama.
• Kepemilikan Tugas: Dalam alih tugas, agen yang menerima alih tugas mengambil kepemilikan penuh atas tugas. Dalam agen sebagai alat, agen utama mempertahankan tanggung jawab keseluruhan untuk tugas, sementara agen lain diperlakukan sebagai alat untuk membantu dalam subtugas tertentu.
• Manajemen Konteks: Dalam orkestrasi handoff, penyerahan percakapan dilakukan kepada agen lain secara penuh. Agen penerima memiliki konteks penuh tentang apa yang telah dilakukan sejauh ini. Dalam agen sebagai alat, agen utama mengelola konteks keseluruhan dan mungkin hanya memberikan informasi yang relevan kepada agen alat sesuai kebutuhan.

Apa yang akan Anda Pelajari

• Cara membuat agen khusus untuk domain yang berbeda
• Cara mengonfigurasi aturan penyerahan antar agen
• Cara membangun alur kerja interaktif dengan perutean agen dinamis
• Cara menangani percakapan berbagai tahap dengan pertukaran agen
• Cara menerapkan persetujuan alat untuk operasi sensitif (HITL)
• Cara menggunakan checkpoint untuk alur kerja serah terima yang andal

Dalam orkestrasi handoff, agen dapat mentransfer kontrol satu sama lain berdasarkan konteks, memungkinkan perutean dinamis dan penanganan berdasarkan keahlian khusus.

Menyiapkan Klien Azure OpenAI

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

Peringatan

DefaultAzureCredential nyaman untuk pengembangan tetapi membutuhkan pertimbangan yang cermat dalam produksi. Dalam produksi, pertimbangkan untuk menggunakan kredensial tertentu (misalnya, ManagedIdentityCredential) untuk menghindari masalah latensi, pemeriksaan kredensial yang tidak diinginkan, dan potensi risiko keamanan dari mekanisme fallback.

Tentukan Agen Khusus Anda

Buat agen khusus untuk domain dan agen triase untuk penyaluran:

// 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");

Mengonfigurasi Aturan Handoff

Tentukan agen mana yang dapat meneruskan tugas ke agen lain.

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

Jalankan Alur Kerja Serah-Terima Interaktif

Kelola percakapan berulang dengan pemindahan agen dinamis:

// 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));
}

Interaksi Contoh

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.

Tentukan beberapa alat untuk demonstrasi

@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."

Menyiapkan Aplikasi Obrolan

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

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

Tentukan Agen Khusus Anda

Buat agen khusus domain dengan koordinator untuk perutean:

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

Mengonfigurasi Aturan Handoff

Buat alur kerja serah terima menggunakan 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()
)

Secara bawaan, semua agen dapat mengalihkan tugas satu sama lain. Untuk perutean yang lebih canggih, Anda dapat mengonfigurasi alih tugas:

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

Nota

Bahkan dengan aturan penyerahan kustom, semua agen masih terhubung dalam topologi jala. Ini karena agen perlu berbagi konteks satu sama lain untuk mempertahankan riwayat percakapan (lihat Sinkronisasi Konteks untuk detail selengkapnya). Aturan serah terima hanya mengatur agen mana yang dapat mengambil alih percakapan berikutnya.

Jalankan Interaksi Agen Perangkat Lunak Handoff

Tidak seperti orkestrasi lain, handoff bersifat interaktif karena agen mungkin tidak memutuskan untuk melakukan handoff setelah setiap giliran. Jika agen tidak melakukan penyerahan, input manusia diperlukan untuk melanjutkan percakapan. Lihat Mode Otonom untuk melewati persyaratan ini. Dalam orkestrasi lain, setelah agen merespons, kontrol masuk ke orkestrator atau agen berikutnya.

Ketika agen dalam alur kerja handoff memutuskan untuk tidak melakukan handoff (handoff dipicu oleh panggilan alat khusus), alur kerja memancarkan WorkflowEvent dengan type="request_info" dan payload yang HandoffAgentUserRequest berisi pesan terbaru agen. Pengguna harus menanggapi permintaan ini untuk melanjutkan alur kerja.

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

Mode Otonom

Orkestrasi Handoff dirancang untuk skenario interaktif di mana input manusia diperlukan ketika agen memutuskan untuk tidak melakukan handoff. Namun, sebagai fitur eksperimental, Anda dapat mengaktifkan "mode otonom" untuk memungkinkan alur kerja berlanjut tanpa intervensi manusia. Dalam mode ini, ketika agen memutuskan untuk tidak melakukan handoff, alur kerja secara otomatis mengirim respons default (misalnyaUser did not respond. Continue assisting autonomously.) ke agen, memungkinkannya untuk melanjutkan percakapan.

Petunjuk / Saran

Mengapa orkestrasi Handoff bersifat interaktif secara inheren? Tidak seperti orkestrasi lain di mana hanya ada satu jalur yang harus diikuti setelah agen merespons (misalnya kembali ke orkestrator atau agen berikutnya), dalam orkestrasi Handoff, agen memiliki opsi untuk melakukan handoff ke agen lain atau terus membantu pengguna itu sendiri. Karena handoff dicapai melalui pemanggilan alat, jika agen tidak memanggil alat handoff tetapi menghasilkan respons, alur kerja tidak akan tahu langkah berikutnya kecuali mendelegasikan kepada pengguna untuk masukan lebih lanjut. Tidak mungkin juga memaksa agen untuk selalu melakukan handoff dengan mengharuskannya menggunakan alat handoff karena kalau tidak, agen tidak akan dapat menghasilkan respons yang bermakna.

Mode Otonom diaktifkan dengan memanggil with_autonomous_mode() di HandoffBuilder. Ini mengonfigurasi alur kerja untuk secara otomatis merespons permintaan input dengan pesan default, memungkinkan agen untuk melanjutkan tanpa menunggu input manusia.

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

Anda juga dapat mengaktifkan mode otonom hanya pada subset agen dengan meneruskan daftar instans agen ke with_autonomous_mode().

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

Anda dapat menyesuaikan pesan respons default.

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

Anda dapat menyesuaikan jumlah giliran yang dapat dijalankan agen secara otonom sebelum memerlukan input manusia. Ini dapat mencegah alur kerja berjalan tanpa batas waktu tanpa keterlibatan pengguna.

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

Tingkat Lanjut: Persetujuan Alat dalam Alur Kerja Handoff

Alur kerja pengalihan dapat mencakup agen dengan alat yang memerlukan persetujuan manusia sebelum pelaksanaan. Ini berguna untuk operasi sensitif seperti memproses pengembalian dana, melakukan pembelian, atau menjalankan tindakan yang tidak dapat diubah.

Tentukanlah Alat yang Memerlukan Persetujuan

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}."

Membuat Agen dengan Alat yang Memerlukan Persetujuan

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

Menangani Permintaan Input Pengguna dan Persetujuan Alat

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!")

Dengan Titik Pemeriksaan untuk Alur Kerja Tahan Lama

Untuk alur kerja yang berjalan lama di mana persetujuan alat mungkin terjadi berjam-jam atau beberapa hari kemudian, gunakan titik pemeriksaan:

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!")

Interaksi Contoh

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?

Sinkronisasi Konteks

Agen dalam Kerangka Kerja Agen bergantung pada sesi agen (AgentSession) untuk mengelola konteks. Dalam orkestrasi Handoff, agen tidak berbagi instance sesi yang sama. Peserta bertanggung jawab untuk memastikan konsistensi konteks. Untuk mencapai hal ini, peserta dirancang untuk menyiarkan respons mereka atau input pengguna yang diterima kepada semua orang lain dalam alur kerja setiap kali mereka menghasilkan respons, memastikan semua peserta memiliki konteks terbaru untuk giliran mereka berikutnya.

Nota

Konten terkait alat, termasuk panggilan alat handoff, tidak disiarkan ke agen lain. Hanya pesan pengguna dan agen yang disinkronkan di semua peserta.

Petunjuk / Saran

Agen tidak berbagi instans sesi yang sama karena jenis agen yang berbeda mungkin memiliki implementasi abstraksi yang AgentSession berbeda. Berbagi instans sesi yang sama dapat menyebabkan inkonsistensi dalam cara setiap agen memproses dan mempertahankan konteks.

Setelah menyiarkan respons, peserta kemudian memeriksa apakah perlu menyerahkan percakapan ke agen lain. Jika demikian, ia mengirimkan permintaan ke agen yang dipilih untuk mengambil alih percakapan. Jika tidak, ia meminta input pengguna atau berlanjut secara otonom berdasarkan konfigurasi alur kerja.

Konsep utama

• Perutean Dinamis: Agen dapat memutuskan agen mana yang harus menangani interaksi berikutnya berdasarkan konteks
• AgentWorkflowBuilder.StartHandoffWith(): Menentukan agen awal yang memulai alur kerja
• WithHandoff() dan WithHandoffs(): Mengonfigurasi aturan handoff antara agen tertentu
• Pelestarian Konteks: Riwayat percakapan lengkap dipertahankan di semua tahap penyerahan.
• Dukungan Multi-giliran: Mendukung percakapan berkelanjutan dengan perpindahan agen yang mulus
• Keahlian Khusus: Setiap agen berfokus pada domain mereka sambil berkolaborasi melalui alih tugas

• Perutean Dinamis: Agen dapat memutuskan agen mana yang harus menangani interaksi berikutnya berdasarkan konteks
• HandoffBuilder: Membuat alur kerja dengan pendaftaran alat handoff otomatis
• with_start_agent(): Menentukan agen mana yang menerima input pengguna terlebih dahulu
• add_handoff(): Mengonfigurasi hubungan handoff tertentu antar agen
• Pelestarian Konteks: Riwayat percakapan lengkap dipertahankan di semua tahap penyerahan.
• Siklus Permintaan/Respons: Alur kerja meminta input pengguna, memproses respons, dan berlanjut hingga kondisi penghentian terpenuhi
• Persetujuan Alat: Gunakan @tool(approval_mode="always_require") untuk operasi sensitif yang memerlukan persetujuan manusia
• FunctionApprovalRequestContent: Dipancarkan saat agen memanggil alat yang memerlukan persetujuan; gunakan create_response(approved=...) untuk merespons
• Checkpoint: Gunakan with_checkpointing() untuk alur kerja konsisten yang bisa dijeda dan dilanjutkan kembali di antara pengulangan proses.
• Keahlian Khusus: Setiap agen berfokus pada domain mereka sambil berkolaborasi melalui alih tugas

Langkah selanjutnya

Orkestrasi Obrolan Grup