Membuat Alur Kerja dengan Logika Percabangan

Dalam tutorial ini, Anda akan mempelajari cara membuat alur kerja dengan logika percabangan menggunakan Agent Framework. Logika percabangan memungkinkan alur kerja Anda membuat keputusan berdasarkan kondisi tertentu, memungkinkan perilaku yang lebih kompleks dan dinamis.

Simpul Bersyarat

Sisi kondisional memungkinkan alur kerja Anda membuat keputusan perutean berdasarkan konten atau properti pesan yang mengalir melalui aliran kerja. Ini memungkinkan pencabangan dinamis di mana jalur eksekusi yang berbeda diambil berdasarkan kondisi runtime.

Apa yang akan Anda Bangun

Anda akan membuat alur kerja pemrosesan email yang menunjukkan perutean kondisional:

Agen deteksi spam yang menganalisis email masuk dan mengembalikan JSON terstruktur.
Jalur kondisional yang merutekan email ke pengelola yang berbeda berdasarkan klasifikasi.
Pengelola email yang sah yang menyusun respons profesional.
Handler spam yang menandai email mencurigakan.
Manajemen status bersama untuk mempertahankan data email di antara langkah-langkah alur kerja.

Konsep yang Tercakup

Sisi Kondisional

Prasyarat

.NET 8.0 SDK atau yang lebih baru.
Titik akhir dan penyebaran layanan Azure OpenAI dikonfigurasi.
Azure CLI diinstal dan diautentikasi (untuk autentikasi kredensial Azure).
Pemahaman dasar tentang pemrograman C# dan asinkron.
Aplikasi konsol baru.

Menginstal paket NuGet

Pertama, instal paket yang diperlukan untuk proyek .NET Anda:

dotnet add package Azure.AI.OpenAI --prerelease
dotnet add package Azure.Identity
dotnet add package Microsoft.Agents.AI.Workflows --prerelease
dotnet add package Microsoft.Extensions.AI.OpenAI --prerelease

Menentukan Model Data

Mulailah dengan menentukan struktur data yang akan mengalir melalui alur kerja Anda:

using System.Text.Json.Serialization;

/// <summary>
/// Represents the result of spam detection.
/// </summary>
public sealed class DetectionResult
{
    [JsonPropertyName("is_spam")]
    public bool IsSpam { get; set; }

    [JsonPropertyName("reason")]
    public string Reason { get; set; } = string.Empty;

    // Email ID is generated by the executor, not the agent
    [JsonIgnore]
    public string EmailId { get; set; } = string.Empty;
}

/// <summary>
/// Represents an email.
/// </summary>
internal sealed class Email
{
    [JsonPropertyName("email_id")]
    public string EmailId { get; set; } = string.Empty;

    [JsonPropertyName("email_content")]
    public string EmailContent { get; set; } = string.Empty;
}

/// <summary>
/// Represents the response from the email assistant.
/// </summary>
public sealed class EmailResponse
{
    [JsonPropertyName("response")]
    public string Response { get; set; } = string.Empty;
}

/// <summary>
/// Constants for shared state scopes.
/// </summary>
internal static class EmailStateConstants
{
    public const string EmailStateScope = "EmailState";
}

Membuat Fungsi Kondisi

Fungsi kondisi mengevaluasi hasil deteksi spam untuk menentukan jalur mana yang harus diambil alur kerja:

/// <summary>
/// Creates a condition for routing messages based on the expected spam detection result.
/// </summary>
/// <param name="expectedResult">The expected spam detection result</param>
/// <returns>A function that evaluates whether a message meets the expected result</returns>
private static Func<object?, bool> GetCondition(bool expectedResult) =>
    detectionResult => detectionResult is DetectionResult result && result.IsSpam == expectedResult;

Fungsi kondisi ini:

bool expectedResult Menerima parameter (true untuk spam, false untuk non-spam)
Mengembalikan fungsi yang dapat digunakan sebagai kondisi batas
Memeriksa dengan aman apakah pesan adalah DetectionResult dan membandingkan properti IsSpam

Membuat Agen AI

Siapkan agen AI yang akan menangani deteksi spam dan bantuan email:

using Azure.AI.OpenAI;
using Azure.Identity;
using Microsoft.Agents.AI;
using Microsoft.Extensions.AI;

/// <summary>
/// Creates a spam detection agent.
/// </summary>
/// <returns>A ChatClientAgent configured for spam detection</returns>
private static ChatClientAgent GetSpamDetectionAgent(IChatClient chatClient) =>
    new(chatClient, new ChatClientAgentOptions(instructions: "You are a spam detection assistant that identifies spam emails.")
    {
        ChatOptions = new()
        {
            ResponseFormat = ChatResponseFormat.ForJsonSchema(AIJsonUtilities.CreateJsonSchema(typeof(DetectionResult)))
        }
    });

/// <summary>
/// Creates an email assistant agent.
/// </summary>
/// <returns>A ChatClientAgent configured for email assistance</returns>
private static ChatClientAgent GetEmailAssistantAgent(IChatClient chatClient) =>
    new(chatClient, new ChatClientAgentOptions(instructions: "You are an email assistant that helps users draft professional responses to emails.")
    {
        ChatOptions = new()
        {
            ResponseFormat = ChatResponseFormat.ForJsonSchema(AIJsonUtilities.CreateJsonSchema(typeof(EmailResponse)))
        }
    });

Menerapkan Pelaksana

Buat pelaksana alur kerja yang menangani berbagai tahap pemrosesan email:

using Microsoft.Agents.AI.Workflows;
using System.Text.Json;

/// <summary>
/// Executor that detects spam using an AI agent.
/// </summary>
internal sealed class SpamDetectionExecutor : Executor<ChatMessage, DetectionResult>
{
    private readonly AIAgent _spamDetectionAgent;

    public SpamDetectionExecutor(AIAgent spamDetectionAgent) : base("SpamDetectionExecutor")
    {
        this._spamDetectionAgent = spamDetectionAgent;
    }

    public override async ValueTask<DetectionResult> HandleAsync(ChatMessage message, IWorkflowContext context, CancellationToken cancellationToken = default)
    {
        // Generate a random email ID and store the email content to shared state
        var newEmail = new Email
        {
            EmailId = Guid.NewGuid().ToString("N"),
            EmailContent = message.Text
        };
        await context.QueueStateUpdateAsync(newEmail.EmailId, newEmail, scopeName: EmailStateConstants.EmailStateScope);

        // Invoke the agent for spam detection
        var response = await this._spamDetectionAgent.RunAsync(message);
        var detectionResult = JsonSerializer.Deserialize<DetectionResult>(response.Text);

        detectionResult!.EmailId = newEmail.EmailId;
        return detectionResult;
    }
}

/// <summary>
/// Executor that assists with email responses using an AI agent.
/// </summary>
internal sealed class EmailAssistantExecutor : Executor<DetectionResult, EmailResponse>
{
    private readonly AIAgent _emailAssistantAgent;

    public EmailAssistantExecutor(AIAgent emailAssistantAgent) : base("EmailAssistantExecutor")
    {
        this._emailAssistantAgent = emailAssistantAgent;
    }

    public override async ValueTask<EmailResponse> HandleAsync(DetectionResult message, IWorkflowContext context, CancellationToken cancellationToken = default)
    {
        if (message.IsSpam)
        {
            throw new ArgumentException("This executor should only handle non-spam messages.");
        }

        // Retrieve the email content from shared state
        var email = await context.ReadStateAsync<Email>(message.EmailId, scopeName: EmailStateConstants.EmailStateScope)
            ?? throw new InvalidOperationException("Email not found.");

        // Invoke the agent to draft a response
        var response = await this._emailAssistantAgent.RunAsync(email.EmailContent);
        var emailResponse = JsonSerializer.Deserialize<EmailResponse>(response.Text);

        return emailResponse!;
    }
}

/// <summary>
/// Executor that sends emails.
/// </summary>
internal sealed class SendEmailExecutor : Executor<EmailResponse>
{
    public SendEmailExecutor() : base("SendEmailExecutor") { }

    public override async ValueTask HandleAsync(EmailResponse message, IWorkflowContext context, CancellationToken cancellationToken = default) =>
        await context.YieldOutputAsync($"Email sent: {message.Response}");
}

/// <summary>
/// Executor that handles spam messages.
/// </summary>
internal sealed class HandleSpamExecutor : Executor<DetectionResult>
{
    public HandleSpamExecutor() : base("HandleSpamExecutor") { }

    public override async ValueTask HandleAsync(DetectionResult message, IWorkflowContext context, CancellationToken cancellationToken = default)
    {
        if (message.IsSpam)
        {
            await context.YieldOutputAsync($"Email marked as spam: {message.Reason}");
        }
        else
        {
            throw new ArgumentException("This executor should only handle spam messages.");
        }
    }
}

Membangun Alur Kerja dengan Tepi Bersyarat

Sekarang buat program utama yang membangun dan menjalankan alur kerja:

using Microsoft.Extensions.AI;

public static class Program
{
    private static async Task Main()
    {
        // Set up the Azure OpenAI client
        var endpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT")
            ?? throw new Exception("AZURE_OPENAI_ENDPOINT is not set.");
        var deploymentName = Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOYMENT_NAME") ?? "gpt-4o-mini";
        var chatClient = new AzureOpenAIClient(new Uri(endpoint), new AzureCliCredential())
            .GetChatClient(deploymentName).AsIChatClient();

        // Create agents
        AIAgent spamDetectionAgent = GetSpamDetectionAgent(chatClient);
        AIAgent emailAssistantAgent = GetEmailAssistantAgent(chatClient);

        // Create executors
        var spamDetectionExecutor = new SpamDetectionExecutor(spamDetectionAgent);
        var emailAssistantExecutor = new EmailAssistantExecutor(emailAssistantAgent);
        var sendEmailExecutor = new SendEmailExecutor();
        var handleSpamExecutor = new HandleSpamExecutor();

        // Build the workflow with conditional edges
        var workflow = new WorkflowBuilder(spamDetectionExecutor)
            // Non-spam path: route to email assistant when IsSpam = false
            .AddEdge(spamDetectionExecutor, emailAssistantExecutor, condition: GetCondition(expectedResult: false))
            .AddEdge(emailAssistantExecutor, sendEmailExecutor)
            // Spam path: route to spam handler when IsSpam = true
            .AddEdge(spamDetectionExecutor, handleSpamExecutor, condition: GetCondition(expectedResult: true))
            .WithOutputFrom(handleSpamExecutor, sendEmailExecutor)
            .Build();

        // Execute the workflow with sample spam email
        string emailContent = "Congratulations! You've won $1,000,000! Click here to claim your prize now!";
        StreamingRun run = await InProcessExecution.StreamAsync(workflow, new ChatMessage(ChatRole.User, emailContent));
        await run.TrySendMessageAsync(new TurnToken(emitEvents: true));

        await foreach (WorkflowEvent evt in run.WatchStreamAsync().ConfigureAwait(false))
        {
            if (evt is WorkflowOutputEvent outputEvent)
            {
                Console.WriteLine($"{outputEvent}");
            }
        }
    }
}

Cara Kerjanya

Entri Alur Kerja: Alur kerja dimulai dengan spamDetectionExecutor menerima ChatMessage.
Analisis Spam: Agen deteksi spam menganalisis email dan mengembalikan DetectionResult terstruktur dengan properti IsSpam dan Reason.
Perutean Bersyarat: Berdasarkan IsSpam nilai yang ditentukan:
- Jika spam (IsSpam = true): Merutekan ke HandleSpamExecutor menggunakan GetCondition(true)
- Jika sah (IsSpam = false): Rute untuk EmailAssistantExecutor menggunakan GetCondition(false)
Pembuatan Respons: Untuk email yang sah, asisten email menyusun respons profesional.
Output Akhir: Alur kerja menghasilkan pemberitahuan spam atau mengirim respons email yang disusun.

Fitur Utama Tepi Bersyarat

Kondisi Aman-Tipe: Metode GetCondition ini membuat fungsi kondisi yang dapat digunakan kembali secara aman untuk mengevaluasi konten pesan.
Beberapa Jalur: Satu eksekutor dapat memiliki beberapa tepi keluar dengan kondisi yang berbeda, memungkinkan logika percabangan yang kompleks.
Status Bersama: Data email bertahan di seluruh pelaksana menggunakan manajemen status tercakup, memungkinkan eksekutor hilir mengakses konten asli.
Penanganan Kesalahan: Eksekutor memvalidasi input mereka dan melemparkan pengecualian yang bermakna saat menerima jenis pesan yang tidak terduga.
Arsitektur Bersih: Setiap eksekutor memiliki satu tanggung jawab, membuat alur kerja dapat dipertahankan dan dapat diuji.

Menjalankan Contoh Program

Saat Anda menjalankan alur kerja ini dengan contoh email spam:

Email marked as spam: This email contains common spam indicators including monetary prizes, urgency tactics, and suspicious links that are typical of phishing attempts.

Coba ubah konten email menjadi sesuatu yang sah:

string emailContent = "Hi, I wanted to follow up on our meeting yesterday and get your thoughts on the project proposal.";

Alur kerja akan merutekan ke asisten email dan menghasilkan respons profesional sebagai gantinya.

Pola perutean kondisional ini membentuk fondasi untuk membangun alur kerja canggih yang dapat menangani pohon keputusan kompleks dan logika bisnis.

Implementasi Lengkap

Untuk implementasi kerja lengkap, lihat sampel ini di repositori Kerangka Kerja Agen.

Apa yang akan Anda Bangun

Anda akan membuat alur kerja pemrosesan email yang menunjukkan perutean kondisional:

Agen deteksi spam yang menganalisis email masuk
Jalur kondisional yang merutekan email ke pengelola yang berbeda berdasarkan klasifikasi
Penangan email sah yang menyusun respons profesional
Handler spam yang menandai email mencurigakan

Konsep yang Tercakup

Sisi Kondisional

Prasyarat

Python 3.10 atau yang lebih baru
Kerangka Kerja Agen terinstal: pip install agent-framework-core --pre
Layanan Azure OpenAI dikonfigurasi dengan variabel lingkungan yang tepat
Autentikasi Azure CLI: az login

Langkah 1: Impor Dependensi yang Diperlukan

Mulailah dengan mengimpor komponen yang diperlukan untuk alur kerja bersyarat.

import asyncio
import os
from dataclasses import dataclass
from typing import Any, Literal
from uuid import uuid4

from typing_extensions import Never

from agent_framework import (
    AgentExecutor,
    AgentExecutorRequest,
    AgentExecutorResponse,
    ChatMessage,
    Role,
    WorkflowBuilder,
    WorkflowContext,
    executor,
    Case,
    Default,
)
from agent_framework.azure import AzureOpenAIChatClient
from azure.identity import AzureCliCredential
from pydantic import BaseModel

Langkah 2: Tentukan Model Data

Buat model Pydantic untuk pertukaran data terstruktur antar komponen alur kerja:

class DetectionResult(BaseModel):
    """Represents the result of spam detection."""
    # is_spam drives the routing decision taken by edge conditions
    is_spam: bool
    # Human readable rationale from the detector
    reason: str
    # The agent must include the original email so downstream agents can operate without reloading content
    email_content: str


class EmailResponse(BaseModel):
    """Represents the response from the email assistant."""
    # The drafted reply that a user could copy or send
    response: str

Langkah 3: Buat Fungsi Kondisi

Tentukan fungsi kondisi yang akan menentukan keputusan perutean:

def get_condition(expected_result: bool):
    """Create a condition callable that routes based on DetectionResult.is_spam."""

    # The returned function will be used as an edge predicate.
    # It receives whatever the upstream executor produced.
    def condition(message: Any) -> bool:
        # Defensive guard. If a non AgentExecutorResponse appears, let the edge pass to avoid dead ends.
        if not isinstance(message, AgentExecutorResponse):
            return True

        try:
            # Prefer parsing a structured DetectionResult from the agent JSON text.
            # Using model_validate_json ensures type safety and raises if the shape is wrong.
            detection = DetectionResult.model_validate_json(message.agent_run_response.text)
            # Route only when the spam flag matches the expected path.
            return detection.is_spam == expected_result
        except Exception:
            # Fail closed on parse errors so we do not accidentally route to the wrong path.
            # Returning False prevents this edge from activating.
            return False

    return condition

Langkah 4: Buat Eksekutor Handler

Tentukan pelaksana untuk menangani hasil perutean yang berbeda:

@executor(id="send_email")
async def handle_email_response(response: AgentExecutorResponse, ctx: WorkflowContext[Never, str]) -> None:
    """Handle legitimate emails by drafting a professional response."""
    # Downstream of the email assistant. Parse a validated EmailResponse and yield the workflow output.
    email_response = EmailResponse.model_validate_json(response.agent_run_response.text)
    await ctx.yield_output(f"Email sent:\n{email_response.response}")


@executor(id="handle_spam")
async def handle_spam_classifier_response(response: AgentExecutorResponse, ctx: WorkflowContext[Never, str]) -> None:
    """Handle spam emails by marking them appropriately."""
    # Spam path. Confirm the DetectionResult and yield the workflow output. Guard against accidental non spam input.
    detection = DetectionResult.model_validate_json(response.agent_run_response.text)
    if detection.is_spam:
        await ctx.yield_output(f"Email marked as spam: {detection.reason}")
    else:
        # This indicates the routing predicate and executor contract are out of sync.
        raise RuntimeError("This executor should only handle spam messages.")


@executor(id="to_email_assistant_request")
async def to_email_assistant_request(
    response: AgentExecutorResponse, ctx: WorkflowContext[AgentExecutorRequest]
) -> None:
    """Transform spam detection response into a request for the email assistant."""
    # Parse the detection result and extract the email content for the assistant
    detection = DetectionResult.model_validate_json(response.agent_run_response.text)

    # Create a new request for the email assistant with the original email content
    request = AgentExecutorRequest(
        messages=[ChatMessage(Role.USER, text=detection.email_content)],
        should_respond=True
    )
    await ctx.send_message(request)

Langkah 5: Membuat Agen AI

Siapkan agen Azure OpenAI dengan pemformatan output terstruktur:

async def main() -> None:
    # Create agents
    # AzureCliCredential uses your current az login. This avoids embedding secrets in code.
    chat_client = AzureOpenAIChatClient(credential=AzureCliCredential())

    # Agent 1. Classifies spam and returns a DetectionResult object.
    # response_format enforces that the LLM returns parsable JSON for the Pydantic model.
    spam_detection_agent = AgentExecutor(
        chat_client.as_agent(
            instructions=(
                "You are a spam detection assistant that identifies spam emails. "
                "Always return JSON with fields is_spam (bool), reason (string), and email_content (string). "
                "Include the original email content in email_content."
            ),
            response_format=DetectionResult,
        ),
        id="spam_detection_agent",
    )

    # Agent 2. Drafts a professional reply. Also uses structured JSON output for reliability.
    email_assistant_agent = AgentExecutor(
        chat_client.as_agent(
            instructions=(
                "You are an email assistant that helps users draft professional responses to emails. "
                "Your input might be a JSON object that includes 'email_content'; base your reply on that content. "
                "Return JSON with a single field 'response' containing the drafted reply."
            ),
            response_format=EmailResponse,
        ),
        id="email_assistant_agent",
    )

Langkah 6: Bangun Alur Kerja Bersyarat

Buat alur kerja dengan tepi kondisional yang merutekan berdasarkan hasil deteksi spam:

    # Build the workflow graph.
    # Start at the spam detector.
    # If not spam, hop to a transformer that creates a new AgentExecutorRequest,
    # then call the email assistant, then finalize.
    # If spam, go directly to the spam handler and finalize.
    workflow = (
        WorkflowBuilder()
        .set_start_executor(spam_detection_agent)
        # Not spam path: transform response -> request for assistant -> assistant -> send email
        .add_edge(spam_detection_agent, to_email_assistant_request, condition=get_condition(False))
        .add_edge(to_email_assistant_request, email_assistant_agent)
        .add_edge(email_assistant_agent, handle_email_response)
        # Spam path: send to spam handler
        .add_edge(spam_detection_agent, handle_spam_classifier_response, condition=get_condition(True))
        .build()
    )

Langkah 7: Jalankan Alur Kerja

Jalankan alur kerja dengan contoh konten email:

    # Read Email content from the sample resource file.
    # This keeps the sample deterministic since the model sees the same email every run.
    email_path = os.path.join(os.path.dirname(os.path.dirname(os.path.realpath(__file__))), "resources", "email.txt")

    with open(email_path) as email_file:  # noqa: ASYNC230
        email = email_file.read()

    # Execute the workflow. Since the start is an AgentExecutor, pass an AgentExecutorRequest.
    # The workflow completes when it becomes idle (no more work to do).
    request = AgentExecutorRequest(messages=[ChatMessage(Role.USER, text=email)], should_respond=True)
    events = await workflow.run(request)
    outputs = events.get_outputs()
    if outputs:
        print(f"Workflow output: {outputs[0]}")


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

Cara Kerja Tepi Bersyarat

Fungsi Kondisi: Fungsi get_condition() membuat predikat yang memeriksa konten pesan dan mengembalikan True atau False untuk menentukan apakah tepi harus dilalui.
Inspeksi Pesan: Kondisi dapat memeriksa aspek pesan apa pun, termasuk data terstruktur dari respons agen yang diurai dengan model Pydantic.
Pemrograman Defensif: Fungsi kondisi mencakup penanganan kesalahan untuk mencegah kegagalan perutean saat mengurai data terstruktur.
Perutean Dinamis: Berdasarkan hasil deteksi spam, email secara otomatis dirutekan ke asisten email (untuk email yang sah) atau penangan spam (untuk email yang mencurigakan).

Konsep Utama

Kondisi Tepi: Predikat Boolean yang menentukan apakah tepi harus dilalui
Output Terstruktur: Menggunakan model Pydantic dengan response_format memastikan penguraian data yang andal
Perutean Defensif: Fungsi kondisi menangani kasus tepi untuk mencegah buntu alur kerja
Transformasi Pesan: Pelaksana dapat mengubah jenis pesan di antara langkah-langkah alur kerja

Implementasi Lengkap

Untuk implementasi kerja lengkap, lihat sampel edge_condition.py di repositori Kerangka Kerja Agen.

Switch-Case Edges

Membangun pada Sisi Bersyarat

Contoh sisi bersyarat sebelumnya mengilustrasikan rute dua arah (spam vs. email yang sah). Namun, banyak skenario dunia nyata membutuhkan pohon keputusan yang lebih canggih. Tepi switch-case menyediakan solusi yang lebih bersih dan lebih dapat dipertahankan ketika Anda perlu merutekan ke beberapa tujuan berdasarkan kondisi yang berbeda.

Apa yang akan Anda buat menggunakan Switch-Case

Anda akan memperluas alur kerja pemrosesan email untuk menangani tiga jalur keputusan:

NotSpam → Asisten Email → Kirim Email
Spam → Menangani Pelaksana Spam
Tidak yakin → Menangani Pelaksana Yang Tidak Pasti (kasus default)

Peningkatan utama adalah menggunakan pola SwitchBuilder alih-alih berbagai tepi kondisional individual, membuat alur kerja lebih mudah dipahami dan dipertahankan seiring dengan meningkatnya kompleksitas keputusan.

Konsep yang Tercakup

Switch-Case Edges

Model Data untuk Switch-Case

Perbarui model data Anda untuk mendukung klasifikasi tiga arah:

/// <summary>
/// Represents the possible decisions for spam detection.
/// </summary>
public enum SpamDecision
{
    NotSpam,
    Spam,
    Uncertain
}

/// <summary>
/// Represents the result of spam detection with enhanced decision support.
/// </summary>
public sealed class DetectionResult
{
    [JsonPropertyName("spam_decision")]
    [JsonConverter(typeof(JsonStringEnumConverter))]
    public SpamDecision spamDecision { get; set; }

    [JsonPropertyName("reason")]
    public string Reason { get; set; } = string.Empty;

    // Email ID is generated by the executor, not the agent
    [JsonIgnore]
    public string EmailId { get; set; } = string.Empty;
}

/// <summary>
/// Represents an email stored in shared state.
/// </summary>
internal sealed class Email
{
    [JsonPropertyName("email_id")]
    public string EmailId { get; set; } = string.Empty;

    [JsonPropertyName("email_content")]
    public string EmailContent { get; set; } = string.Empty;
}

/// <summary>
/// Represents the response from the email assistant.
/// </summary>
public sealed class EmailResponse
{
    [JsonPropertyName("response")]
    public string Response { get; set; } = string.Empty;
}

/// <summary>
/// Constants for shared state scopes.
/// </summary>
internal static class EmailStateConstants
{
    public const string EmailStateScope = "EmailState";
}

Pabrik Kondisi untuk Switch-Case

Buat pabrik kondisi yang dapat digunakan kembali yang menghasilkan predikat untuk setiap keputusan spam:

/// <summary>
/// Creates a condition for routing messages based on the expected spam detection result.
/// </summary>
/// <param name="expectedDecision">The expected spam detection decision</param>
/// <returns>A function that evaluates whether a message meets the expected result</returns>
private static Func<object?, bool> GetCondition(SpamDecision expectedDecision) =>
    detectionResult => detectionResult is DetectionResult result && result.spamDecision == expectedDecision;

Pendekatan pabrik ini:

Mengurangi Duplikasi Kode: Satu fungsi menghasilkan semua predikat kondisi
Memastikan Konsistensi: Semua kondisi mengikuti pola yang sama
Menyederhanakan Pemeliharaan: Perubahan logika kondisi terjadi di satu tempat

Agen AI yang Ditingkatkan

Perbarui agen deteksi spam agar kurang percaya diri dan kembalikan klasifikasi tiga arah:

/// <summary>
/// Creates a spam detection agent with enhanced uncertainty handling.
/// </summary>
/// <returns>A ChatClientAgent configured for three-way spam detection</returns>
private static ChatClientAgent GetSpamDetectionAgent(IChatClient chatClient) =>
    new(chatClient, new ChatClientAgentOptions(instructions: "You are a spam detection assistant that identifies spam emails. Be less confident in your assessments.")
    {
        ChatOptions = new()
        {
            ResponseFormat = ChatResponseFormat.ForJsonSchema<DetectionResult>()
        }
    });

/// <summary>
/// Creates an email assistant agent (unchanged from conditional edges example).
/// </summary>
/// <returns>A ChatClientAgent configured for email assistance</returns>
private static ChatClientAgent GetEmailAssistantAgent(IChatClient chatClient) =>
    new(chatClient, new ChatClientAgentOptions(instructions: "You are an email assistant that helps users draft responses to emails with professionalism.")
    {
        ChatOptions = new()
        {
            ResponseFormat = ChatResponseFormat.ForJsonSchema<EmailResponse>()
        }
    });

Pelaksana Proses Kerja dengan Perutean yang Ditingkatkan

Terapkan pelaksana yang menangani perutean tiga arah dengan manajemen status bersama:

/// <summary>
/// Executor that detects spam using an AI agent with three-way classification.
/// </summary>
internal sealed class SpamDetectionExecutor : Executor<ChatMessage, DetectionResult>
{
    private readonly AIAgent _spamDetectionAgent;

    public SpamDetectionExecutor(AIAgent spamDetectionAgent) : base("SpamDetectionExecutor")
    {
        this._spamDetectionAgent = spamDetectionAgent;
    }

    public override async ValueTask<DetectionResult> HandleAsync(ChatMessage message, IWorkflowContext context, CancellationToken cancellationToken = default)
    {
        // Generate a random email ID and store the email content in shared state
        var newEmail = new Email
        {
            EmailId = Guid.NewGuid().ToString("N"),
            EmailContent = message.Text
        };
        await context.QueueStateUpdateAsync(newEmail.EmailId, newEmail, scopeName: EmailStateConstants.EmailStateScope);

        // Invoke the agent for enhanced spam detection
        var response = await this._spamDetectionAgent.RunAsync(message);
        var detectionResult = JsonSerializer.Deserialize<DetectionResult>(response.Text);

        detectionResult!.EmailId = newEmail.EmailId;
        return detectionResult;
    }
}

/// <summary>
/// Executor that assists with email responses using an AI agent.
/// </summary>
internal sealed class EmailAssistantExecutor : Executor<DetectionResult, EmailResponse>
{
    private readonly AIAgent _emailAssistantAgent;

    public EmailAssistantExecutor(AIAgent emailAssistantAgent) : base("EmailAssistantExecutor")
    {
        this._emailAssistantAgent = emailAssistantAgent;
    }

    public override async ValueTask<EmailResponse> HandleAsync(DetectionResult message, IWorkflowContext context, CancellationToken cancellationToken = default)
    {
        if (message.spamDecision == SpamDecision.Spam)
        {
            throw new ArgumentException("This executor should only handle non-spam messages.");
        }

        // Retrieve the email content from shared state
        var email = await context.ReadStateAsync<Email>(message.EmailId, scopeName: EmailStateConstants.EmailStateScope);

        // Invoke the agent to draft a response
        var response = await this._emailAssistantAgent.RunAsync(email!.EmailContent);
        var emailResponse = JsonSerializer.Deserialize<EmailResponse>(response.Text);

        return emailResponse!;
    }
}

/// <summary>
/// Executor that sends emails.
/// </summary>
internal sealed class SendEmailExecutor : Executor<EmailResponse>
{
    public SendEmailExecutor() : base("SendEmailExecutor") { }

    public override async ValueTask HandleAsync(EmailResponse message, IWorkflowContext context, CancellationToken cancellationToken = default) =>
        await context.YieldOutputAsync($"Email sent: {message.Response}").ConfigureAwait(false);
}

/// <summary>
/// Executor that handles spam messages.
/// </summary>
internal sealed class HandleSpamExecutor : Executor<DetectionResult>
{
    public HandleSpamExecutor() : base("HandleSpamExecutor") { }

    public override async ValueTask HandleAsync(DetectionResult message, IWorkflowContext context, CancellationToken cancellationToken = default)
    {
        if (message.spamDecision == SpamDecision.Spam)
        {
            await context.YieldOutputAsync($"Email marked as spam: {message.Reason}").ConfigureAwait(false);
        }
        else
        {
            throw new ArgumentException("This executor should only handle spam messages.");
        }
    }
}

/// <summary>
/// Executor that handles uncertain emails requiring manual review.
/// </summary>
internal sealed class HandleUncertainExecutor : Executor<DetectionResult>
{
    public HandleUncertainExecutor() : base("HandleUncertainExecutor") { }

    public override async ValueTask HandleAsync(DetectionResult message, IWorkflowContext context, CancellationToken cancellationToken = default)
    {
        if (message.spamDecision == SpamDecision.Uncertain)
        {
            var email = await context.ReadStateAsync<Email>(message.EmailId, scopeName: EmailStateConstants.EmailStateScope);
            await context.YieldOutputAsync($"Email marked as uncertain: {message.Reason}. Email content: {email?.EmailContent}");
        }
        else
        {
            throw new ArgumentException("This executor should only handle uncertain spam decisions.");
        }
    }
}

Bangun Aliran Kerja dengan Pola Switch-Case

Ganti beberapa tepi kondisi dengan pola switch-case yang lebih bersih:

public static class Program
{
    private static async Task Main()
    {
        // Set up the Azure OpenAI client
        var endpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT") ?? throw new Exception("AZURE_OPENAI_ENDPOINT is not set.");
        var deploymentName = Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOYMENT_NAME") ?? "gpt-4o-mini";
        var chatClient = new AzureOpenAIClient(new Uri(endpoint), new AzureCliCredential()).GetChatClient(deploymentName).AsIChatClient();

        // Create agents
        AIAgent spamDetectionAgent = GetSpamDetectionAgent(chatClient);
        AIAgent emailAssistantAgent = GetEmailAssistantAgent(chatClient);

        // Create executors
        var spamDetectionExecutor = new SpamDetectionExecutor(spamDetectionAgent);
        var emailAssistantExecutor = new EmailAssistantExecutor(emailAssistantAgent);
        var sendEmailExecutor = new SendEmailExecutor();
        var handleSpamExecutor = new HandleSpamExecutor();
        var handleUncertainExecutor = new HandleUncertainExecutor();

        // Build the workflow using switch-case for cleaner three-way routing
        WorkflowBuilder builder = new(spamDetectionExecutor);
        builder.AddSwitch(spamDetectionExecutor, switchBuilder =>
            switchBuilder
            .AddCase(
                GetCondition(expectedDecision: SpamDecision.NotSpam),
                emailAssistantExecutor
            )
            .AddCase(
                GetCondition(expectedDecision: SpamDecision.Spam),
                handleSpamExecutor
            )
            .WithDefault(
                handleUncertainExecutor
            )
        )
        // After the email assistant writes a response, it will be sent to the send email executor
        .AddEdge(emailAssistantExecutor, sendEmailExecutor)
        .WithOutputFrom(handleSpamExecutor, sendEmailExecutor, handleUncertainExecutor);

        var workflow = builder.Build();

        // Read an email from a text file (use ambiguous content for demonstration)
        string email = Resources.Read("ambiguous_email.txt");

        // Execute the workflow
        StreamingRun run = await InProcessExecution.StreamAsync(workflow, new ChatMessage(ChatRole.User, email));
        await run.TrySendMessageAsync(new TurnToken(emitEvents: true));
        await foreach (WorkflowEvent evt in run.WatchStreamAsync().ConfigureAwait(false))
        {
            if (evt is WorkflowOutputEvent outputEvent)
            {
                Console.WriteLine($"{outputEvent}");
            }
        }
    }
}

Manfaat Switch-Case

Sintaks Yang Lebih Bersih: SwitchBuilder menyediakan alternatif yang lebih mudah dibaca untuk beberapa tepi bersyarah
Evaluasi Yang Diurutkan: Kasus dievaluasi secara berurutan, berhenti pada kecocokan pertama
Perutean Terjamin: Metode WithDefault() ini memastikan pesan tidak pernah macet
Pemeliharaan yang Lebih Baik: Menambahkan kasus baru memerlukan perubahan minimal pada struktur alur kerja
Keselamatan Tipe: Setiap eksekutor memvalidasi inputnya untuk menangkap kesalahan perutean sedini mungkin

Perbandingan Pola

Sebelum (Edge Kondisional):

var workflow = new WorkflowBuilder(spamDetectionExecutor)
    .AddEdge(spamDetectionExecutor, emailAssistantExecutor, condition: GetCondition(expectedResult: false))
    .AddEdge(spamDetectionExecutor, handleSpamExecutor, condition: GetCondition(expectedResult: true))
    // No clean way to handle a third case
    .WithOutputFrom(handleSpamExecutor, sendEmailExecutor)
    .Build();

Setelah (Switch-Case):

WorkflowBuilder builder = new(spamDetectionExecutor);
builder.AddSwitch(spamDetectionExecutor, switchBuilder =>
    switchBuilder
    .AddCase(GetCondition(SpamDecision.NotSpam), emailAssistantExecutor)
    .AddCase(GetCondition(SpamDecision.Spam), handleSpamExecutor)
    .WithDefault(handleUncertainExecutor)  // Clean default case
)
// Continue building the rest of the workflow

Pola switch-case berkembang lebih efektif seiring bertambahnya jumlah keputusan perutean, dan kasus default berfungsi sebagai jaring pengaman untuk nilai yang tidak terduga.

Menjalankan Contoh Program

Saat Anda menjalankan alur kerja ini dengan konten email ambigu:

Email marked as uncertain: This email contains promotional language but might be from a legitimate business contact, requiring human review for proper classification.

Coba ubah konten email menjadi sesuatu yang jelas spam atau jelas sah untuk melihat jalur perutean yang berbeda dalam tindakan.

Implementasi Lengkap

Untuk implementasi kerja lengkap, lihat sampel ini di repositori Kerangka Kerja Agen.

Membangun pada Sisi Bersyarat

Apa yang akan Anda Bangun Berikutnya

Anda akan memperluas alur kerja pemrosesan email untuk menangani tiga jalur keputusan:

NotSpam → Asisten Email → Kirim Email
Spam → Tandai sebagai Spam
Tidak Pasti → Tandai untuk Peninjauan Manual (kasus default)

Peningkatan utama adalah menggunakan satu grup tepi switch-case alih-alih beberapa tepi bersyarat individu, membuat alur kerja lebih mudah dipahami dan dipertahankan seiring dengan bertambahnya kompleksitas keputusan.

Konsep yang Tercakup

Switch-Case Edges

Model Data yang Ditingkatkan

Perbarui model data Anda untuk mendukung klasifikasi tiga arah:

from typing import Literal

class DetectionResultAgent(BaseModel):
    """Structured output returned by the spam detection agent."""

    # The agent classifies the email into one of three categories
    spam_decision: Literal["NotSpam", "Spam", "Uncertain"]
    reason: str

class EmailResponse(BaseModel):
    """Structured output returned by the email assistant agent."""

    response: str

@dataclass
class DetectionResult:
    """Internal typed payload used for routing and downstream handling."""

    spam_decision: str
    reason: str
    email_id: str

@dataclass
class Email:
    """In memory record of the email content stored in shared state."""

    email_id: str
    email_content: str

Kondisi Switch-Case Pabrik

Buat pabrik kondisi yang dapat digunakan kembali yang menghasilkan predikat untuk setiap keputusan spam:

def get_case(expected_decision: str):
    """Factory that returns a predicate matching a specific spam_decision value."""

    def condition(message: Any) -> bool:
        # Only match when the upstream payload is a DetectionResult with the expected decision
        return isinstance(message, DetectionResult) and message.spam_decision == expected_decision

    return condition

Pendekatan pabrik ini:

Mengurangi Duplikasi Kode: Satu fungsi menghasilkan semua predikat kondisi
Memastikan Konsistensi: Semua kondisi mengikuti pola yang sama
Menyederhanakan Pemeliharaan: Perubahan logika kondisi terjadi di satu tempat

Pelaksana Alur Kerja dengan Status Bersama

Terapkan pelaksana yang menggunakan status bersama untuk menghindari meneruskan konten email besar melalui setiap langkah alur kerja:

EMAIL_STATE_PREFIX = "email:"
CURRENT_EMAIL_ID_KEY = "current_email_id"

@executor(id="store_email")
async def store_email(email_text: str, ctx: WorkflowContext[AgentExecutorRequest]) -> None:
    """Store email content once and pass around a lightweight ID reference."""

    # Persist the raw email content in shared state
    new_email = Email(email_id=str(uuid4()), email_content=email_text)
    await ctx.set_shared_state(f"{EMAIL_STATE_PREFIX}{new_email.email_id}", new_email)
    await ctx.set_shared_state(CURRENT_EMAIL_ID_KEY, new_email.email_id)

    # Forward email to spam detection agent
    await ctx.send_message(
        AgentExecutorRequest(messages=[ChatMessage(Role.USER, text=new_email.email_content)], should_respond=True)
    )

@executor(id="to_detection_result")
async def to_detection_result(response: AgentExecutorResponse, ctx: WorkflowContext[DetectionResult]) -> None:
    """Transform agent response into a typed DetectionResult with email ID."""

    # Parse the agent's structured JSON output
    parsed = DetectionResultAgent.model_validate_json(response.agent_run_response.text)
    email_id: str = await ctx.get_shared_state(CURRENT_EMAIL_ID_KEY)

    # Create typed message for switch-case routing
    await ctx.send_message(DetectionResult(
        spam_decision=parsed.spam_decision,
        reason=parsed.reason,
        email_id=email_id
    ))

@executor(id="submit_to_email_assistant")
async def submit_to_email_assistant(detection: DetectionResult, ctx: WorkflowContext[AgentExecutorRequest]) -> None:
    """Handle NotSpam emails by forwarding to the email assistant."""

    # Guard against misrouting
    if detection.spam_decision != "NotSpam":
        raise RuntimeError("This executor should only handle NotSpam messages.")

    # Retrieve original email content from shared state
    email: Email = await ctx.get_shared_state(f"{EMAIL_STATE_PREFIX}{detection.email_id}")
    await ctx.send_message(
        AgentExecutorRequest(messages=[ChatMessage(Role.USER, text=email.email_content)], should_respond=True)
    )

@executor(id="finalize_and_send")
async def finalize_and_send(response: AgentExecutorResponse, ctx: WorkflowContext[Never, str]) -> None:
    """Parse email assistant response and yield final output."""

    parsed = EmailResponse.model_validate_json(response.agent_run_response.text)
    await ctx.yield_output(f"Email sent: {parsed.response}")

@executor(id="handle_spam")
async def handle_spam(detection: DetectionResult, ctx: WorkflowContext[Never, str]) -> None:
    """Handle confirmed spam emails."""

    if detection.spam_decision == "Spam":
        await ctx.yield_output(f"Email marked as spam: {detection.reason}")
    else:
        raise RuntimeError("This executor should only handle Spam messages.")

@executor(id="handle_uncertain")
async def handle_uncertain(detection: DetectionResult, ctx: WorkflowContext[Never, str]) -> None:
    """Handle uncertain classifications that need manual review."""

    if detection.spam_decision == "Uncertain":
        # Include original content for human review
        email: Email | None = await ctx.get_shared_state(f"{EMAIL_STATE_PREFIX}{detection.email_id}")
        await ctx.yield_output(
            f"Email marked as uncertain: {detection.reason}. Email content: {getattr(email, 'email_content', '')}"
        )
    else:
        raise RuntimeError("This executor should only handle Uncertain messages.")

Membuat Agen AI yang Ditingkatkan

Perbarui agen deteksi spam agar kurang percaya diri dan kembalikan klasifikasi tiga arah:

async def main():
    chat_client = AzureOpenAIChatClient(credential=AzureCliCredential())

    # Enhanced spam detection agent with three-way classification
    spam_detection_agent = AgentExecutor(
        chat_client.as_agent(
            instructions=(
                "You are a spam detection assistant that identifies spam emails. "
                "Be less confident in your assessments. "
                "Always return JSON with fields 'spam_decision' (one of NotSpam, Spam, Uncertain) "
                "and 'reason' (string)."
            ),
            response_format=DetectionResultAgent,
        ),
        id="spam_detection_agent",
    )

    # Email assistant remains the same
    email_assistant_agent = AgentExecutor(
        chat_client.as_agent(
            instructions=(
                "You are an email assistant that helps users draft responses to emails with professionalism."
            ),
            response_format=EmailResponse,
        ),
        id="email_assistant_agent",
    )

Bangun Alur Kerja dengan Switch-Case Edge Group

Ganti beberapa tepi kondisional dengan satu grup sakelar:

    # Build workflow using switch-case for cleaner three-way routing
    workflow = (
        WorkflowBuilder()
        .set_start_executor(store_email)
        .add_edge(store_email, spam_detection_agent)
        .add_edge(spam_detection_agent, to_detection_result)
        .add_switch_case_edge_group(
            to_detection_result,
            [
                # Explicit cases for specific decisions
                Case(condition=get_case("NotSpam"), target=submit_to_email_assistant),
                Case(condition=get_case("Spam"), target=handle_spam),
                # Default case catches anything that doesn't match above
                Default(target=handle_uncertain),
            ],
        )
        .add_edge(submit_to_email_assistant, email_assistant_agent)
        .add_edge(email_assistant_agent, finalize_and_send)
        .build()
    )

Jalankan dan Uji

Jalankan alur kerja dengan konten email ambigu yang menunjukkan perutean tiga arah:

    # Use ambiguous email content that might trigger uncertain classification
    email = (
        "Hey there, I noticed you might be interested in our latest offer—no pressure, but it expires soon. "
        "Let me know if you'd like more details."
    )

    # Execute and display results
    events = await workflow.run(email)
    outputs = events.get_outputs()
    if outputs:
        for output in outputs:
            print(f"Workflow output: {output}")

Keuntungan Utama Switch-Case Edges

Sintaks Yang Lebih Bersih: Satu grup tepi alih-alih beberapa tepi kondisional
Evaluasi Yang Diurutkan: Kasus dievaluasi secara berurutan, berhenti pada kecocokan pertama
Perutean Terjamin: Kasus default memastikan pesan tidak pernah macet
Ketahanan yang Lebih Baik: Menambahkan kasus baru memerlukan perubahan minimal
Keamanan Tipe: Setiap eksekutor memvalidasi inputnya dalam mendeteksi kesalahan perutean

Perbandingan: Pernyataan Bersyarat vs. Switch-Case

Sebelum (Edge Kondisional):

.add_edge(detector, handler_a, condition=lambda x: x.result == "A")
.add_edge(detector, handler_b, condition=lambda x: x.result == "B")
.add_edge(detector, handler_c, condition=lambda x: x.result == "C")

Setelah (Switch-Case):

.add_switch_case_edge_group(
    detector,
    [
        Case(condition=lambda x: x.result == "A", target=handler_a),
        Case(condition=lambda x: x.result == "B", target=handler_b),
        Default(target=handler_c),  # Catches everything else
    ],
)

Pola switch-case berkembang lebih efektif seiring bertambahnya jumlah keputusan perutean, dan kasus default berfungsi sebagai jaring pengaman untuk nilai yang tidak terduga.

Kode Sampel Switch-Case

Untuk implementasi kerja lengkap, lihat sampel switch_case_edge_group.py di repositori Kerangka Kerja Agen.

Garis Multi-Pilihan

Lebih dari sekadar Switch-Case: Perutean Multi-pilihan

Meskipun tepi switch-case merutekan pesan ke tepat satu tujuan, alur kerja dunia nyata sering kali perlu memicu beberapa operasi paralel berdasarkan karakteristik data. Tepi yang dipartisi (diimplementasikan sebagai tepi fan-out dengan partisi) memungkinkan pola fan-out canggih di mana satu pesan dapat mengaktifkan beberapa eksekutor hilir secara bersamaan.

Alur Kerja Pemrosesan Email Tingkat Lanjut

Berdasarkan contoh switch-case, Anda akan merancang sistem pemrosesan email yang lebih canggih yang menunjukkan logika perutean yang kompleks:

Email spam → Penanganan spam tunggal (seperti switch-case)
Email yang sah → Selalu memicu asisten email + Secara kondisional memicu alat peringkas untuk email panjang
Email yang tidak pasti → Pengelola tunggal yang tidak pasti (seperti switch-case)
Persistensi database → Dipicu untuk email pendek dan email panjang yang diringkas

Pola ini memungkinkan alur pemrosesan paralel yang beradaptasi dengan karakteristik konten.

Konsep yang Tercakup

Tepi Fan-out

Model Data untuk Pemilihan Ganda

Perluas model data untuk mendukung analisis dan ringkasan panjang email:

/// <summary>
/// Represents the result of enhanced email analysis with additional metadata.
/// </summary>
public sealed class AnalysisResult
{
    [JsonPropertyName("spam_decision")]
    [JsonConverter(typeof(JsonStringEnumConverter))]
    public SpamDecision spamDecision { get; set; }

    [JsonPropertyName("reason")]
    public string Reason { get; set; } = string.Empty;

    // Additional properties for sophisticated routing
    [JsonIgnore]
    public int EmailLength { get; set; }

    [JsonIgnore]
    public string EmailSummary { get; set; } = string.Empty;

    [JsonIgnore]
    public string EmailId { get; set; } = string.Empty;
}

/// <summary>
/// Represents the response from the email assistant.
/// </summary>
public sealed class EmailResponse
{
    [JsonPropertyName("response")]
    public string Response { get; set; } = string.Empty;
}

/// <summary>
/// Represents the response from the email summary agent.
/// </summary>
public sealed class EmailSummary
{
    [JsonPropertyName("summary")]
    public string Summary { get; set; } = string.Empty;
}

/// <summary>
/// A custom workflow event for database operations.
/// </summary>
internal sealed class DatabaseEvent(string message) : WorkflowEvent(message) { }

/// <summary>
/// Constants for email processing thresholds.
/// </summary>
public static class EmailProcessingConstants
{
    public const int LongEmailThreshold = 100;
}

Fungsi Penugasan Target: Inti dari Multi-Select

Fungsi penugasan target menentukan pelaksana mana yang harus menerima setiap pesan:

/// <summary>
/// Creates a target assigner for routing messages based on the analysis result.
/// </summary>
/// <returns>A function that takes an analysis result and returns the target partitions.</returns>
private static Func<AnalysisResult?, int, IEnumerable<int>> GetTargetAssigner()
{
    return (analysisResult, targetCount) =>
    {
        if (analysisResult is not null)
        {
            if (analysisResult.spamDecision == SpamDecision.Spam)
            {
                return [0]; // Route only to spam handler (index 0)
            }
            else if (analysisResult.spamDecision == SpamDecision.NotSpam)
            {
                // Always route to email assistant (index 1)
                List<int> targets = [1];

                // Conditionally add summarizer for long emails (index 2)
                if (analysisResult.EmailLength > EmailProcessingConstants.LongEmailThreshold)
                {
                    targets.Add(2);
                }

                return targets;
            }
            else // Uncertain
            {
                return [3]; // Route only to uncertain handler (index 3)
            }
        }
        throw new ArgumentException("Invalid analysis result.");
    };
}

Fitur Utama Fungsi Target Assigner

Pilihan Target Dinamis: Mengembalikan daftar indeks pelaksana untuk diaktifkan
Perutean Sadar Konten: Membuat keputusan berdasarkan properti pesan seperti panjang email
Pemrosesan Paralel: Beberapa target dapat dijalankan secara bersamaan
Logika Kondisional: Percabangan kompleks berdasarkan beberapa kriteria

Pelaksana Alur Kerja yang Disempurnakan

Terapkan pelaksana yang menangani analisis dan perutean tingkat lanjut:

/// <summary>
/// Executor that analyzes emails using an AI agent with enhanced analysis.
/// </summary>
internal sealed class EmailAnalysisExecutor : Executor<ChatMessage, AnalysisResult>
{
    private readonly AIAgent _emailAnalysisAgent;

    public EmailAnalysisExecutor(AIAgent emailAnalysisAgent) : base("EmailAnalysisExecutor")
    {
        this._emailAnalysisAgent = emailAnalysisAgent;
    }

    public override async ValueTask<AnalysisResult> HandleAsync(ChatMessage message, IWorkflowContext context, CancellationToken cancellationToken = default)
    {
        // Generate a random email ID and store the email content
        var newEmail = new Email
        {
            EmailId = Guid.NewGuid().ToString("N"),
            EmailContent = message.Text
        };
        await context.QueueStateUpdateAsync(newEmail.EmailId, newEmail, scopeName: EmailStateConstants.EmailStateScope);

        // Invoke the agent for enhanced analysis
        var response = await this._emailAnalysisAgent.RunAsync(message);
        var analysisResult = JsonSerializer.Deserialize<AnalysisResult>(response.Text);

        // Enrich with metadata for routing decisions
        analysisResult!.EmailId = newEmail.EmailId;
        analysisResult.EmailLength = newEmail.EmailContent.Length;

        return analysisResult;
    }
}

/// <summary>
/// Executor that assists with email responses using an AI agent.
/// </summary>
internal sealed class EmailAssistantExecutor : Executor<AnalysisResult, EmailResponse>
{
    private readonly AIAgent _emailAssistantAgent;

    public EmailAssistantExecutor(AIAgent emailAssistantAgent) : base("EmailAssistantExecutor")
    {
        this._emailAssistantAgent = emailAssistantAgent;
    }

    public override async ValueTask<EmailResponse> HandleAsync(AnalysisResult message, IWorkflowContext context, CancellationToken cancellationToken = default)
    {
        if (message.spamDecision == SpamDecision.Spam)
        {
            throw new ArgumentException("This executor should only handle non-spam messages.");
        }

        // Retrieve the email content from shared state
        var email = await context.ReadStateAsync<Email>(message.EmailId, scopeName: EmailStateConstants.EmailStateScope);

        // Invoke the agent to draft a response
        var response = await this._emailAssistantAgent.RunAsync(email!.EmailContent);
        var emailResponse = JsonSerializer.Deserialize<EmailResponse>(response.Text);

        return emailResponse!;
    }
}

/// <summary>
/// Executor that summarizes emails using an AI agent for long emails.
/// </summary>
internal sealed class EmailSummaryExecutor : Executor<AnalysisResult, AnalysisResult>
{
    private readonly AIAgent _emailSummaryAgent;

    public EmailSummaryExecutor(AIAgent emailSummaryAgent) : base("EmailSummaryExecutor")
    {
        this._emailSummaryAgent = emailSummaryAgent;
    }

    public override async ValueTask<AnalysisResult> HandleAsync(AnalysisResult message, IWorkflowContext context, CancellationToken cancellationToken = default)
    {
        // Read the email content from shared state
        var email = await context.ReadStateAsync<Email>(message.EmailId, scopeName: EmailStateConstants.EmailStateScope);

        // Generate summary for long emails
        var response = await this._emailSummaryAgent.RunAsync(email!.EmailContent);
        var emailSummary = JsonSerializer.Deserialize<EmailSummary>(response.Text);

        // Enrich the analysis result with the summary
        message.EmailSummary = emailSummary!.Summary;

        return message;
    }
}

/// <summary>
/// Executor that sends emails.
/// </summary>
internal sealed class SendEmailExecutor : Executor<EmailResponse>
{
    public SendEmailExecutor() : base("SendEmailExecutor") { }

    public override async ValueTask HandleAsync(EmailResponse message, IWorkflowContext context, CancellationToken cancellationToken = default) =>
        await context.YieldOutputAsync($"Email sent: {message.Response}");
}

/// <summary>
/// Executor that handles spam messages.
/// </summary>
internal sealed class HandleSpamExecutor : Executor<AnalysisResult>
{
    public HandleSpamExecutor() : base("HandleSpamExecutor") { }

    public override async ValueTask HandleAsync(AnalysisResult message, IWorkflowContext context, CancellationToken cancellationToken = default)
    {
        if (message.spamDecision == SpamDecision.Spam)
        {
            await context.YieldOutputAsync($"Email marked as spam: {message.Reason}");
        }
        else
        {
            throw new ArgumentException("This executor should only handle spam messages.");
        }
    }
}

/// <summary>
/// Executor that handles uncertain messages requiring manual review.
/// </summary>
internal sealed class HandleUncertainExecutor : Executor<AnalysisResult>
{
    public HandleUncertainExecutor() : base("HandleUncertainExecutor") { }

    public override async ValueTask HandleAsync(AnalysisResult message, IWorkflowContext context, CancellationToken cancellationToken = default)
    {
        if (message.spamDecision == SpamDecision.Uncertain)
        {
            var email = await context.ReadStateAsync<Email>(message.EmailId, scopeName: EmailStateConstants.EmailStateScope);
            await context.YieldOutputAsync($"Email marked as uncertain: {message.Reason}. Email content: {email?.EmailContent}");
        }
        else
        {
            throw new ArgumentException("This executor should only handle uncertain spam decisions.");
        }
    }
}

/// <summary>
/// Executor that handles database access with custom events.
/// </summary>
internal sealed class DatabaseAccessExecutor : Executor<AnalysisResult>
{
    public DatabaseAccessExecutor() : base("DatabaseAccessExecutor") { }

    public override async ValueTask HandleAsync(AnalysisResult message, IWorkflowContext context, CancellationToken cancellationToken = default)
    {
        // Simulate database operations
        await context.ReadStateAsync<Email>(message.EmailId, scopeName: EmailStateConstants.EmailStateScope);
        await Task.Delay(100); // Simulate database access delay

        // Emit custom database event for monitoring
        await context.AddEventAsync(new DatabaseEvent($"Email {message.EmailId} saved to database."));
    }
}

Agen AI yang Ditingkatkan

Buat agen untuk analisis, bantuan, dan ringkasan:

/// <summary>
/// Create an enhanced email analysis agent.
/// </summary>
/// <returns>A ChatClientAgent configured for comprehensive email analysis</returns>
private static ChatClientAgent GetEmailAnalysisAgent(IChatClient chatClient) =>
    new(chatClient, new ChatClientAgentOptions(instructions: "You are a spam detection assistant that identifies spam emails.")
    {
        ChatOptions = new()
        {
            ResponseFormat = ChatResponseFormat.ForJsonSchema<AnalysisResult>()
        }
    });

/// <summary>
/// Creates an email assistant agent.
/// </summary>
/// <returns>A ChatClientAgent configured for email assistance</returns>
private static ChatClientAgent GetEmailAssistantAgent(IChatClient chatClient) =>
    new(chatClient, new ChatClientAgentOptions(instructions: "You are an email assistant that helps users draft responses to emails with professionalism.")
    {
        ChatOptions = new()
        {
            ResponseFormat = ChatResponseFormat.ForJsonSchema<EmailResponse>()
        }
    });

/// <summary>
/// Creates an agent that summarizes emails.
/// </summary>
/// <returns>A ChatClientAgent configured for email summarization</returns>
private static ChatClientAgent GetEmailSummaryAgent(IChatClient chatClient) =>
    new(chatClient, new ChatClientAgentOptions(instructions: "You are an assistant that helps users summarize emails.")
    {
        ChatOptions = new()
        {
            ResponseFormat = ChatResponseFormat.ForJsonSchema<EmailSummary>()
        }
    });

Pembangunan Alur Kerja Multi-Pilihan

Konstruksi alur kerja dengan routing canggih dan pemrosesan paralel:

public static class Program
{
    private static async Task Main()
    {
        // Set up the Azure OpenAI client
        var endpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT") ?? throw new Exception("AZURE_OPENAI_ENDPOINT is not set.");
        var deploymentName = Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOYMENT_NAME") ?? "gpt-4o-mini";
        var chatClient = new AzureOpenAIClient(new Uri(endpoint), new AzureCliCredential()).GetChatClient(deploymentName).AsIChatClient();

        // Create agents
        AIAgent emailAnalysisAgent = GetEmailAnalysisAgent(chatClient);
        AIAgent emailAssistantAgent = GetEmailAssistantAgent(chatClient);
        AIAgent emailSummaryAgent = GetEmailSummaryAgent(chatClient);

        // Create executors
        var emailAnalysisExecutor = new EmailAnalysisExecutor(emailAnalysisAgent);
        var emailAssistantExecutor = new EmailAssistantExecutor(emailAssistantAgent);
        var emailSummaryExecutor = new EmailSummaryExecutor(emailSummaryAgent);
        var sendEmailExecutor = new SendEmailExecutor();
        var handleSpamExecutor = new HandleSpamExecutor();
        var handleUncertainExecutor = new HandleUncertainExecutor();
        var databaseAccessExecutor = new DatabaseAccessExecutor();

        // Build the workflow with multi-selection fan-out
        WorkflowBuilder builder = new(emailAnalysisExecutor);
        builder.AddFanOutEdge(
            emailAnalysisExecutor,
            targets: [
                handleSpamExecutor,        // Index 0: Spam handler
                emailAssistantExecutor,    // Index 1: Email assistant (always for NotSpam)
                emailSummaryExecutor,      // Index 2: Summarizer (conditionally for long NotSpam)
                handleUncertainExecutor,   // Index 3: Uncertain handler
            ],
            targetSelector: GetTargetAssigner()
        )
        // Email assistant branch
        .AddEdge(emailAssistantExecutor, sendEmailExecutor)

        // Database persistence: conditional routing
        .AddEdge<AnalysisResult>(
            emailAnalysisExecutor,
            databaseAccessExecutor,
            condition: analysisResult => analysisResult?.EmailLength <= EmailProcessingConstants.LongEmailThreshold) // Short emails
        .AddEdge(emailSummaryExecutor, databaseAccessExecutor) // Long emails with summary

        .WithOutputFrom(handleUncertainExecutor, handleSpamExecutor, sendEmailExecutor);

        var workflow = builder.Build();

        // Read a moderately long email to trigger both assistant and summarizer
        string email = Resources.Read("email.txt");

        // Execute the workflow with custom event handling
        StreamingRun run = await InProcessExecution.StreamAsync(workflow, new ChatMessage(ChatRole.User, email));
        await run.TrySendMessageAsync(new TurnToken(emitEvents: true));
        await foreach (WorkflowEvent evt in run.WatchStreamAsync().ConfigureAwait(false))
        {
            if (evt is WorkflowOutputEvent outputEvent)
            {
                Console.WriteLine($"Output: {outputEvent}");
            }

            if (evt is DatabaseEvent databaseEvent)
            {
                Console.WriteLine($"Database: {databaseEvent}");
            }
        }
    }
}

Pola Perbandingan: Pemilihan-Multi vs. Switch-Case

PolaSwitch-Case (Sebelumnya):

// One input → exactly one output
builder.AddSwitch(spamDetectionExecutor, switchBuilder =>
    switchBuilder
    .AddCase(GetCondition(SpamDecision.NotSpam), emailAssistantExecutor)
    .AddCase(GetCondition(SpamDecision.Spam), handleSpamExecutor)
    .WithDefault(handleUncertainExecutor)
)

Pola Pemilihan Ganda:

// One input → one or more outputs (dynamic fan-out)
builder.AddFanOutEdge(
    emailAnalysisExecutor,
    targets: [handleSpamExecutor, emailAssistantExecutor, emailSummaryExecutor, handleUncertainExecutor],
    targetSelector: GetTargetAssigner() // Returns list of target indices
)

Keuntungan Utama dari Tepi Pemilihan Ganda

Pemrosesan Paralel: Beberapa cabang dapat dijalankan secara bersamaan
Conditional Fan-out: Jumlah target bervariasi berdasarkan konten bersyarat
Perutean Sadar Konten: Keputusan berdasarkan properti pesan, bukan hanya mengetik
Penggunaan Sumber Daya yang Efisien: Hanya cabang yang diperlukan yang diaktifkan
Logika Bisnis Kompleks: Mendukung skenario rute yang canggih

Menjalankan Contoh Pilihan Ganda

Saat Anda menjalankan alur kerja ini dengan email panjang:

Output: Email sent: [Professional response generated by AI]
Database: Email abc123 saved to database.

Saat Anda menjalankan dengan email singkat, ringkasan dilewati:

Output: Email sent: [Professional response generated by AI]
Database: Email def456 saved to database.

Real-World Kasus Penggunaan

Sistem Email: Rutekan ke asisten balasan + arsip + analitik (secara kondisional)
Pemrosesan Konten: Transkripsi pemicu + terjemahan + analisis (berdasarkan jenis konten)
Pemrosesan Pesanan: Rute ke pemenuhan + penagihan + pemberitahuan (berdasarkan properti pesanan)
Alur Data: Memicu alur analitik yang berbeda berdasarkan karakteristik data

Implementasi Multi-Seleksi yang Lengkap

Untuk implementasi kerja lengkap, lihat sampel ini di repositori Kerangka Kerja Agen.

Lebih dari sekadar Switch-Case: Perutean Multi-pilihan

Meskipun tepi switch-case merutekan pesan ke tepat satu tujuan, alur kerja dunia nyata sering kali perlu memicu beberapa operasi paralel berdasarkan karakteristik data. Tepi yang dipartisi (diimplementasikan sebagai grup tepi multi-pilihan) memungkinkan pola fan-out canggih di mana satu pesan dapat mengaktifkan beberapa eksekutor hilir secara bersamaan.

Alur Kerja Pemrosesan Email Tingkat Lanjut

Berdasarkan contoh switch-case, Anda akan merancang sistem pemrosesan email yang lebih canggih yang menunjukkan logika perutean yang kompleks:

Email spam → Penanganan spam tunggal (seperti switch-case)
Email yang sah → Selalu memicu asisten email + Secara kondisional memicu alat peringkas untuk email panjang
Email yang tidak pasti → Pengelola tunggal yang tidak pasti (seperti switch-case)
Persistensi database → Dipicu untuk email pendek dan email panjang yang diringkas

Pola ini memungkinkan alur pemrosesan paralel yang beradaptasi dengan karakteristik konten.

Konsep yang Tercakup

Fan-Out Edges

Model Data yang Ditingkatkan untuk Pemilihan Ganda

Perluas model data untuk mendukung analisis dan ringkasan panjang email:

class AnalysisResultAgent(BaseModel):
    """Enhanced structured output from email analysis agent."""

    spam_decision: Literal["NotSpam", "Spam", "Uncertain"]
    reason: str

class EmailResponse(BaseModel):
    """Response from email assistant."""

    response: str

class EmailSummaryModel(BaseModel):
    """Summary generated by email summary agent."""

    summary: str

@dataclass
class AnalysisResult:
    """Internal analysis result with email metadata for routing decisions."""

    spam_decision: str
    reason: str
    email_length: int  # Used for conditional routing
    email_summary: str  # Populated by summary agent
    email_id: str

@dataclass
class Email:
    """Email content stored in shared state."""

    email_id: str
    email_content: str

# Custom event for database operations
class DatabaseEvent(WorkflowEvent):
    """Custom event for tracking database operations."""
    pass

Fungsi Pemilihan: Inti dari Multi-Pilihan

Fungsi pemilihan menentukan pelaksana mana yang harus menerima setiap pesan:

LONG_EMAIL_THRESHOLD = 100

def select_targets(analysis: AnalysisResult, target_ids: list[str]) -> list[str]:
    """Intelligent routing based on spam decision and email characteristics."""

    # Target order: [handle_spam, submit_to_email_assistant, summarize_email, handle_uncertain]
    handle_spam_id, submit_to_email_assistant_id, summarize_email_id, handle_uncertain_id = target_ids

    if analysis.spam_decision == "Spam":
        # Route only to spam handler
        return [handle_spam_id]

    elif analysis.spam_decision == "NotSpam":
        # Always route to email assistant
        targets = [submit_to_email_assistant_id]

        # Conditionally add summarizer for long emails
        if analysis.email_length > LONG_EMAIL_THRESHOLD:
            targets.append(summarize_email_id)

        return targets

    else:  # Uncertain
        # Route only to uncertain handler
        return [handle_uncertain_id]

Fitur Utama Fungsi Pemilihan

Pilihan Target Dinamis: Mengembalikan daftar ID eksekutor untuk diaktifkan
Perutean Sadar Konten: Membuat keputusan berdasarkan properti pesan
Pemrosesan Paralel: Beberapa target dapat dijalankan secara bersamaan
Logika Kondisional: Percabangan kompleks berdasarkan beberapa kriteria

Pelaksana Alur Kerja Multi-Pilihan

Terapkan pelaksana yang menangani analisis dan perutean yang ditingkatkan:

EMAIL_STATE_PREFIX = "email:"
CURRENT_EMAIL_ID_KEY = "current_email_id"

@executor(id="store_email")
async def store_email(email_text: str, ctx: WorkflowContext[AgentExecutorRequest]) -> None:
    """Store email and initiate analysis."""

    new_email = Email(email_id=str(uuid4()), email_content=email_text)
    await ctx.set_shared_state(f"{EMAIL_STATE_PREFIX}{new_email.email_id}", new_email)
    await ctx.set_shared_state(CURRENT_EMAIL_ID_KEY, new_email.email_id)

    await ctx.send_message(
        AgentExecutorRequest(messages=[ChatMessage(Role.USER, text=new_email.email_content)], should_respond=True)
    )

@executor(id="to_analysis_result")
async def to_analysis_result(response: AgentExecutorResponse, ctx: WorkflowContext[AnalysisResult]) -> None:
    """Transform agent response into enriched analysis result."""

    parsed = AnalysisResultAgent.model_validate_json(response.agent_run_response.text)
    email_id: str = await ctx.get_shared_state(CURRENT_EMAIL_ID_KEY)
    email: Email = await ctx.get_shared_state(f"{EMAIL_STATE_PREFIX}{email_id}")

    # Create enriched analysis result with email length for routing decisions
    await ctx.send_message(
        AnalysisResult(
            spam_decision=parsed.spam_decision,
            reason=parsed.reason,
            email_length=len(email.email_content),  # Key for conditional routing
            email_summary="",
            email_id=email_id,
        )
    )

@executor(id="submit_to_email_assistant")
async def submit_to_email_assistant(analysis: AnalysisResult, ctx: WorkflowContext[AgentExecutorRequest]) -> None:
    """Handle legitimate emails by forwarding to email assistant."""

    if analysis.spam_decision != "NotSpam":
        raise RuntimeError("This executor should only handle NotSpam messages.")

    email: Email = await ctx.get_shared_state(f"{EMAIL_STATE_PREFIX}{analysis.email_id}")
    await ctx.send_message(
        AgentExecutorRequest(messages=[ChatMessage(Role.USER, text=email.email_content)], should_respond=True)
    )

@executor(id="finalize_and_send")
async def finalize_and_send(response: AgentExecutorResponse, ctx: WorkflowContext[Never, str]) -> None:
    """Final step for email assistant branch."""

    parsed = EmailResponse.model_validate_json(response.agent_run_response.text)
    await ctx.yield_output(f"Email sent: {parsed.response}")

@executor(id="summarize_email")
async def summarize_email(analysis: AnalysisResult, ctx: WorkflowContext[AgentExecutorRequest]) -> None:
    """Generate summary for long emails (parallel branch)."""

    # Only called for long NotSpam emails by selection function
    email: Email = await ctx.get_shared_state(f"{EMAIL_STATE_PREFIX}{analysis.email_id}")
    await ctx.send_message(
        AgentExecutorRequest(messages=[ChatMessage(Role.USER, text=email.email_content)], should_respond=True)
    )

@executor(id="merge_summary")
async def merge_summary(response: AgentExecutorResponse, ctx: WorkflowContext[AnalysisResult]) -> None:
    """Merge summary back into analysis result for database persistence."""

    summary = EmailSummaryModel.model_validate_json(response.agent_run_response.text)
    email_id: str = await ctx.get_shared_state(CURRENT_EMAIL_ID_KEY)
    email: Email = await ctx.get_shared_state(f"{EMAIL_STATE_PREFIX}{email_id}")

    # Create analysis result with summary for database storage
    await ctx.send_message(
        AnalysisResult(
            spam_decision="NotSpam",
            reason="",
            email_length=len(email.email_content),
            email_summary=summary.summary,  # Now includes summary
            email_id=email_id,
        )
    )

@executor(id="handle_spam")
async def handle_spam(analysis: AnalysisResult, ctx: WorkflowContext[Never, str]) -> None:
    """Handle spam emails (single target like switch-case)."""

    if analysis.spam_decision == "Spam":
        await ctx.yield_output(f"Email marked as spam: {analysis.reason}")
    else:
        raise RuntimeError("This executor should only handle Spam messages.")

@executor(id="handle_uncertain")
async def handle_uncertain(analysis: AnalysisResult, ctx: WorkflowContext[Never, str]) -> None:
    """Handle uncertain emails (single target like switch-case)."""

    if analysis.spam_decision == "Uncertain":
        email: Email | None = await ctx.get_shared_state(f"{EMAIL_STATE_PREFIX}{analysis.email_id}")
        await ctx.yield_output(
            f"Email marked as uncertain: {analysis.reason}. Email content: {getattr(email, 'email_content', '')}"
        )
    else:
        raise RuntimeError("This executor should only handle Uncertain messages.")

@executor(id="database_access")
async def database_access(analysis: AnalysisResult, ctx: WorkflowContext[Never, str]) -> None:
    """Simulate database persistence with custom events."""

    await asyncio.sleep(0.05)  # Simulate DB operation
    await ctx.add_event(DatabaseEvent(f"Email {analysis.email_id} saved to database."))

Agen AI yang Ditingkatkan

Buat agen untuk analisis, bantuan, dan ringkasan:

async def main() -> None:
    chat_client = AzureOpenAIChatClient(credential=AzureCliCredential())

    # Enhanced analysis agent
    email_analysis_agent = AgentExecutor(
        chat_client.as_agent(
            instructions=(
                "You are a spam detection assistant that identifies spam emails. "
                "Always return JSON with fields 'spam_decision' (one of NotSpam, Spam, Uncertain) "
                "and 'reason' (string)."
            ),
            response_format=AnalysisResultAgent,
        ),
        id="email_analysis_agent",
    )

    # Email assistant (same as before)
    email_assistant_agent = AgentExecutor(
        chat_client.as_agent(
            instructions=(
                "You are an email assistant that helps users draft responses to emails with professionalism."
            ),
            response_format=EmailResponse,
        ),
        id="email_assistant_agent",
    )

    # New: Email summary agent for long emails
    email_summary_agent = AgentExecutor(
        chat_client.as_agent(
            instructions="You are an assistant that helps users summarize emails.",
            response_format=EmailSummaryModel,
        ),
        id="email_summary_agent",
    )

Membangun Alur Kerja Pemilihan Ganda

Konstruksi alur kerja dengan routing canggih dan pemrosesan paralel:

    workflow = (
        WorkflowBuilder()
        .set_start_executor(store_email)
        .add_edge(store_email, email_analysis_agent)
        .add_edge(email_analysis_agent, to_analysis_result)

        # Multi-selection edge group: intelligent fan-out based on content
        .add_multi_selection_edge_group(
            to_analysis_result,
            [handle_spam, submit_to_email_assistant, summarize_email, handle_uncertain],
            selection_func=select_targets,
        )

        # Email assistant branch (always for NotSpam)
        .add_edge(submit_to_email_assistant, email_assistant_agent)
        .add_edge(email_assistant_agent, finalize_and_send)

        # Summary branch (only for long NotSpam emails)
        .add_edge(summarize_email, email_summary_agent)
        .add_edge(email_summary_agent, merge_summary)

        # Database persistence: conditional routing
        .add_edge(to_analysis_result, database_access,
                 condition=lambda r: r.email_length <= LONG_EMAIL_THRESHOLD)  # Short emails
        .add_edge(merge_summary, database_access)  # Long emails with summary

        .build()
    )

Eksekusi dengan Event Streaming

Jalankan alur kerja dan amati eksekusi paralel melalui peristiwa kustom:

    # Use a moderately long email to trigger both assistant and summarizer
    email = """
    Hello team, here are the updates for this week:

    1. Project Alpha is on track and we should have the first milestone completed by Friday.
    2. The client presentation has been scheduled for next Tuesday at 2 PM.
    3. Please review the Q4 budget allocation and provide feedback by Wednesday.

    Let me know if you have any questions or concerns.

    Best regards,
    Alex
    """

    # Stream events to see parallel execution
    async for event in workflow.run_stream(email):
        if isinstance(event, DatabaseEvent):
            print(f"Database: {event}")
        elif isinstance(event, WorkflowOutputEvent):
            print(f"Output: {event.data}")

Perbandingan Pilihan Berganda vs. Switch-Case

PolaSwitch-Case (Sebelumnya):

# One input → exactly one output
.add_switch_case_edge_group(
    source,
    [
        Case(condition=lambda x: x.result == "A", target=handler_a),
        Case(condition=lambda x: x.result == "B", target=handler_b),
        Default(target=handler_c),
    ],
)

Pola Pemilihan Ganda:

# One input → one or more outputs (dynamic fan-out)
.add_multi_selection_edge_group(
    source,
    [handler_a, handler_b, handler_c, handler_d],
    selection_func=intelligent_router,  # Returns list of target IDs
)

C# Manfaat Multi-Pilihan

Pemrosesan Paralel: Beberapa cabang dapat dijalankan secara bersamaan
Conditional Fan-out: Jumlah target bervariasi berdasarkan konten bersyarat
Perutean Sadar Konten: Keputusan berdasarkan properti pesan, bukan hanya mengetik
Penggunaan Sumber Daya yang Efisien: Hanya cabang yang diperlukan yang diaktifkan
Logika Bisnis Kompleks: Mendukung skenario rute yang canggih

Aplikasi C# Real-World

Sistem Email: Rutekan ke asisten balasan + arsip + analitik (secara kondisional)
Pemrosesan Konten: Transkripsi pemicu + terjemahan + analisis (berdasarkan jenis konten)
Pemrosesan Pesanan: Rute ke pemenuhan + penagihan + pemberitahuan (berdasarkan properti pesanan)
Alur Data: Memicu alur analitik yang berbeda berdasarkan karakteristik data

Kode Sampel Pemilihan Ganda

Untuk implementasi kerja lengkap, lihat sampel multi_selection_edge_group.py di repositori Kerangka Kerja Agen.

Langkah Selanjutnya

Pelajari tentang menangani permintaan dan respons dalam alur kerja

Saran dan Komentar

Apakah halaman ini membantu?

Last updated on 2025-11-21

Bagikan melalui

Membuat Alur Kerja dengan Logika Percabangan

Simpul Bersyarat

Apa yang akan Anda Bangun

Konsep yang Tercakup

Prasyarat

Menginstal paket NuGet

Menentukan Model Data

Membuat Fungsi Kondisi

Membuat Agen AI

Menerapkan Pelaksana

Membangun Alur Kerja dengan Tepi Bersyarat

Cara Kerjanya

Fitur Utama Tepi Bersyarat

Menjalankan Contoh Program

Implementasi Lengkap

Apa yang akan Anda Bangun

Konsep yang Tercakup

Prasyarat

Langkah 1: Impor Dependensi yang Diperlukan

Langkah 2: Tentukan Model Data

Langkah 3: Buat Fungsi Kondisi

Langkah 4: Buat Eksekutor Handler

Langkah 5: Membuat Agen AI

Langkah 6: Bangun Alur Kerja Bersyarat

Langkah 7: Jalankan Alur Kerja

Cara Kerja Tepi Bersyarat

Konsep Utama

Implementasi Lengkap

Switch-Case Edges

Membangun pada Sisi Bersyarat

Apa yang akan Anda buat menggunakan Switch-Case

Konsep yang Tercakup

Model Data untuk Switch-Case

Pabrik Kondisi untuk Switch-Case

Agen AI yang Ditingkatkan

Pelaksana Proses Kerja dengan Perutean yang Ditingkatkan

Bangun Aliran Kerja dengan Pola Switch-Case

Manfaat Switch-Case

Perbandingan Pola

Menjalankan Contoh Program

Implementasi Lengkap

Membangun pada Sisi Bersyarat

Apa yang akan Anda Bangun Berikutnya

Konsep yang Tercakup

Model Data yang Ditingkatkan

Kondisi Switch-Case Pabrik

Pelaksana Alur Kerja dengan Status Bersama

Membuat Agen AI yang Ditingkatkan

Bangun Alur Kerja dengan Switch-Case Edge Group

Jalankan dan Uji

Keuntungan Utama Switch-Case Edges

Perbandingan: Pernyataan Bersyarat vs. Switch-Case

Kode Sampel Switch-Case

Garis Multi-Pilihan

Lebih dari sekadar Switch-Case: Perutean Multi-pilihan

Alur Kerja Pemrosesan Email Tingkat Lanjut

Konsep yang Tercakup

Model Data untuk Pemilihan Ganda

Fungsi Penugasan Target: Inti dari Multi-Select

Fitur Utama Fungsi Target Assigner

Pelaksana Alur Kerja yang Disempurnakan

Agen AI yang Ditingkatkan

Pembangunan Alur Kerja Multi-Pilihan

Pola Perbandingan: Pemilihan-Multi vs. Switch-Case

Keuntungan Utama dari Tepi Pemilihan Ganda

Menjalankan Contoh Pilihan Ganda

Real-World Kasus Penggunaan

Implementasi Multi-Seleksi yang Lengkap

Lebih dari sekadar Switch-Case: Perutean Multi-pilihan

Alur Kerja Pemrosesan Email Tingkat Lanjut

Konsep yang Tercakup

Model Data yang Ditingkatkan untuk Pemilihan Ganda

Fungsi Pemilihan: Inti dari Multi-Pilihan

Fitur Utama Fungsi Pemilihan

Pelaksana Alur Kerja Multi-Pilihan

Agen AI yang Ditingkatkan

Membangun Alur Kerja Pemilihan Ganda

Eksekusi dengan Event Streaming

Perbandingan Pilihan Berganda vs. Switch-Case