Orkestrasi Alur Kerja Kerangka Kerja Agen Microsoft - Berurutan

Dalam orkestrasi berurutan, agen diatur dalam alur di mana setiap agen memproses tugas secara bergantian, meneruskan output ke agen berikutnya secara berurutan.

Menyiapkan Klien Azure OpenAI

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Azure.AI.Projects;
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 AIProjectClient(new Uri(endpoint), new DefaultAzureCredential())
    .GetProjectOpenAIClient()
    .GetProjectResponsesClient()
    .AsIChatClient(deploymentName);

Buat agen khusus yang akan berfungsi secara berurutan:

// 2) Helper method to create translation agents
static ChatClientAgent GetTranslationAgent(string targetLanguage, IChatClient chatClient) =>
    new(chatClient,
        $"You are a translation assistant who only responds in {targetLanguage}. Respond to any " +
        $"input by outputting the name of the input language and then translating the input to {targetLanguage}.");

// Create translation agents for sequential processing
var translationAgents = (from lang in (string[])["French", "Spanish", "English"]
                         select GetTranslationAgent(lang, client));

Menyiapkan Orkestrasi Berurutan

Bangun alur kerja menggunakan AgentWorkflowBuilder:

// 3) Build sequential workflow
var workflow = AgentWorkflowBuilder.BuildSequential(translationAgents);

Jalankan Alur Kerja Berurutan

Jalankan alur kerja dan proses peristiwa:

// 4) Run the workflow
var messages = new List<ChatMessage> { new(ChatRole.User, "Hello, world!") };

await using StreamingRun run = await InProcessExecution.RunStreamingAsync(workflow, messages);
await run.TrySendMessageAsync(new TurnToken(emitEvents: true));

string? lastExecutorId = null;
List<ChatMessage> result = [];
await foreach (WorkflowEvent evt in run.WatchStreamAsync())
{
    if (evt is AgentResponseUpdateEvent e)
    {
        if (e.ExecutorId != lastExecutorId)
        {
            lastExecutorId = e.ExecutorId;
            Console.WriteLine();
            Console.Write($"{e.ExecutorId}: ");
        }

        Console.Write(e.Update.Text);
    }
    else if (evt is WorkflowOutputEvent outputEvt)
    {
        result = outputEvt.As<List<ChatMessage>>()!;
        break;
    }
}

// Display final result
Console.WriteLine();
foreach (var message in result)
{
    Console.WriteLine($"{message.Role}: {message.Text}");
}

Sampel Output

French_Translation: User: Hello, world!
French_Translation: Assistant: English detected. Bonjour, le monde !
Spanish_Translation: Assistant: French detected. ¡Hola, mundo!
English_Translation: Assistant: Spanish detected. Hello, world!

Orkestrasi Berurutan dengan Human-in-the-Loop

Orkestrasi berurutan mendukung interaksi human-in-the-loop melalui persetujuan alat. Saat agen menggunakan alat yang dibalut dengan ApprovalRequiredAIFunction, alur kerja menjeda dan memancarkan RequestInfoEvent yang berisi ToolApprovalRequestContent. Sistem eksternal (seperti operator manusia) dapat memeriksa panggilan alat, menyetujui atau menolaknya, dan alur kerja dilanjutkan.

Tentukan Agen dengan Alat yang Memerlukan Persetujuan

Buat agen di mana alat sensitif dibungkus dengan ApprovalRequiredAIFunction:

ChatClientAgent deployAgent = new(
    client,
    "You are a DevOps engineer. Check staging status first, then deploy to production.",
    "DeployAgent",
    "Handles deployments",
    [
        AIFunctionFactory.Create(CheckStagingStatus),
        new ApprovalRequiredAIFunction(AIFunctionFactory.Create(DeployToProduction))
    ]);

ChatClientAgent verifyAgent = new(
    client,
    "You are a QA engineer. Verify that the deployment was successful and summarize the results.",
    "VerifyAgent",
    "Verifies deployments");

Membangun dan Menjalankan dengan Penanganan Persetujuan

Bangun alur kerja berurutan secara normal. Alur persetujuan ditangani melalui aliran peristiwa:

var workflow = AgentWorkflowBuilder.BuildSequential([deployAgent, verifyAgent]);

await foreach (WorkflowEvent evt in run.WatchStreamAsync())
{
    if (evt is RequestInfoEvent e &&
        e.Request.TryGetDataAs(out ToolApprovalRequestContent? approvalRequest))
    {
        await run.SendResponseAsync(
            e.Request.CreateResponse(approvalRequest.CreateResponse(approved: true)));
    }
}

Lebih dari Persetujuan Alat: Umpan Balik Interaktif

Persetujuan penggunaan alat memungkinkan manusia menerima atau menolak pemanggilan alat tertentu, tetapi orkestrasi berurutan tidak mencakup langkah bawaan untuk berhenti sejenak guna menunggu masukan bebas dari pengguna di antara agen, dan tidak dapat mengembalikan kendali ke agen sebelumnya. Ketika agen perlu secara interaktif meminta informasi lebih lanjut kepada pengguna dan melakukan iterasi sebelum melanjutkan; misalnya, mengumpulkan detail pemesanan sebelum memanggil alat reservasi; gunakan salah satu pendekatan berikut sebagai gantinya:

• Orkestrasi handoff secara bawaan bersifat interaktif: ketika agen merespons tanpa melakukan handoff, kontrol kembali ke pengguna untuk masukan berikutnya, sehingga memungkinkan interaksi bolak-balik multi-turn dalam orkestrasi. Batasi setiap agen ke satu tujuan handoff untuk menyerupai alur sekuensial yang tetap berhenti sejenak untuk menunggu masukan pengguna.
• Alur kerja kustom yang dibangun dengan WorkflowBuilder dan RequestPort memungkinkan Anda mengirim permintaan bertipe kepada pengguna pada titik mana pun dan merutekan respons kembali ke eksekutor, yang dapat Anda tempatkan sebelum atau sesudah agen Anda dalam pipeline.

Konsep utama

• Pemrosesan Berurutan: Setiap agen memproses output agen sebelumnya secara berurutan
• AgentWorkflowBuilder.BuildSequential(): Membuat alur kerja dari kumpulan agen
• ChatClientAgent: Mewakili agen yang didukung oleh klien obrolan dengan instruksi tertentu
• InProcessExecution.RunStreamingAsync(): Menjalankan alur kerja dan mengembalikan StreamingRun untuk streaming peristiwa real time
• Penanganan Peristiwa: Memantau kemajuan agen melalui AgentResponseUpdateEvent dan penyelesaian melalui WorkflowOutputEvent
• Persetujuan Alat: Membungkus alat sensitif dengan ApprovalRequiredAIFunction untuk memerlukan persetujuan manusia sebelum eksekusi
• RequestInfoEvent: Dikeluarkan ketika alat memerlukan persetujuan; berisi ToolApprovalRequestContent dengan detail panggilan alat
• HITL Interaktif: Orkestrasi berurutan mencakup persetujuan alat; untuk interaksi dua arah yang interaktif ketika agen mengumpulkan lebih banyak informasi dari pengguna, gunakan orkestrasi handoff atau alur kerja kustom RequestPort

Dalam orkestrasi berurutan, setiap agen memproses tugas secara bergantian, dengan output mengalir dari satu ke yang berikutnya. Mulailah dengan menentukan agen untuk proses dua tahap:

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

# 1) Create agents using FoundryChatClient
chat_client = FoundryChatClient(
    project_endpoint=os.environ["FOUNDRY_PROJECT_ENDPOINT"],
    model=os.environ["FOUNDRY_MODEL"],
    credential=AzureCliCredential(),
)

writer = chat_client.as_agent(
    instructions=(
        "You are a concise copywriter. Provide a single, punchy marketing sentence based on the prompt."
    ),
    name="writer",
)

reviewer = chat_client.as_agent(
    instructions=(
        "You are a thoughtful reviewer. Give brief feedback on the previous assistant message."
    ),
    name="reviewer",
)

Menyiapkan Orkestrasi Berurutan

Kelas SequentialBuilder membuat alur tempat agen memproses tugas secara berurutan. Setiap agen melihat riwayat percakapan lengkap dan menambahkan respons mereka:

from agent_framework.orchestrations import SequentialBuilder

# 2) Build sequential workflow: writer -> reviewer
workflow = SequentialBuilder(participants=[writer, reviewer]).build()

Jalankan Alur Kerja Berurutan

Jalankan alur kerja dan kumpulkan output akhir. Output terminal adalah yang AgentResponse berisi pesan respons agen terakhir:

from agent_framework import AgentResponse

# 3) Run and print the last agent's response
events = await workflow.run("Write a tagline for a budget-friendly eBike.")
outputs = events.get_outputs()

if outputs:
    print("===== Final Response =====")
    final: AgentResponse = outputs[0]
    for msg in final.messages:
        name = msg.author_name or "assistant"
        print(f"[{name}]\n{msg.text}")

Sampel Output

===== Final Response =====
[reviewer]
This tagline clearly communicates affordability and the benefit of extended travel, making it
appealing to budget-conscious consumers. It has a friendly and motivating tone, though it could
be slightly shorter for more punch. Overall, a strong and effective suggestion!

Tingkat Lanjut: Menggabungkan Agen dengan Eksekutor Kustom

Orkestrasi berurutan mendukung penggabungan agen dengan eksekutor kustom untuk pemrosesan khusus. Ini berguna ketika Anda memerlukan logika kustom yang tidak memerlukan LLM:

Tentukan Pelaksana Kustom

from agent_framework import AgentExecutorResponse, AgentResponse, Executor, WorkflowContext, handler
from agent_framework import Message
from typing_extensions import Never

class Summarizer(Executor):
    """Terminator custom executor: consumes full conversation and yields a summary as the workflow's final answer."""

    @handler
    async def summarize(
        self,
        agent_response: AgentExecutorResponse,
        ctx: WorkflowContext[Never, AgentResponse]
    ) -> None:
        if not agent_response.full_conversation:
            await ctx.yield_output(AgentResponse(messages=[Message("assistant", ["No conversation to summarize."])]))
            return

        users = sum(1 for m in agent_response.full_conversation if m.role == "user")
        assistants = sum(1 for m in agent_response.full_conversation if m.role == "assistant")
        summary = Message("assistant", [f"Summary -> users:{users} assistants:{assistants}"])
        await ctx.yield_output(AgentResponse(messages=[summary]))

Membangun Alur Kerja Berurutan Campuran

# Create a content agent
content = chat_client.as_agent(
    instructions="Produce a concise paragraph answering the user's request.",
    name="content",
)

# Build sequential workflow: content -> summarizer
summarizer = Summarizer(id="summarizer")
workflow = SequentialBuilder(participants=[content, summarizer]).build()

Output Sampel dengan Eksekutor Kustom

===== Final Summary =====
Summary -> users:1 assistants:1

Mengontrol Konteks Antar Agen

Secara default, setiap agen dalam SequentialBuilder alur kerja menggunakan percakapan lengkap agen sebelumnya (input + pesan respons). Pengaturan chain_only_agent_responses=True mengonfigurasi semua agen dalam urutan untuk hanya menggunakan pesan respons agen sebelumnya sebagai gantinya:

workflow = SequentialBuilder(
    participants=[writer, translator, reviewer],
    chain_only_agent_responses=True,
).build()

Ini berguna untuk alur terjemahan, penyempurnaan progresif, dan skenario lain di mana setiap agen harus fokus hanya pada transformasi output agen sebelumnya tanpa dipengaruhi oleh giliran percakapan sebelumnya.

Untuk contoh lengkapnya, lihat sequential_chain_only_agent_responses.py di repositori Kerangka Kerja Agen.

Hasil Sementara

Secara default, SequentialBuilder menunjuk peserta terakhir sebagai sumber output terminal (output_from). Hanya keluaran peserta tersebut yang muncul sebagai peristiwa "output".

Untuk menampilkan juga hasil peserta sebelumnya, sertakan intermediate_output_from beserta peserta yang ingin Anda tetapkan sebagai sumber perantara. Ini secara implisit mengeluarkan peserta tersebut dari kelompok default-final — mereka menghasilkan peristiwa "intermediate", bukan peristiwa "output":

workflow = SequentialBuilder(
    participants=[writer, reviewer, editor],
    intermediate_output_from=[writer, reviewer],
).build()

Anda dapat menangani peristiwa "intermediate" dan "output" secara real time dalam mode streaming:

from agent_framework import AgentResponseUpdate

# Track the last author to format streaming output.
last_author: str | None = None

async for event in workflow.run("Write a tagline for a budget-friendly eBike.", stream=True):
    if event.type in ("output", "intermediate") and isinstance(event.data, AgentResponseUpdate):
        update = event.data
        author = update.author_name
        if author != last_author:
            if last_author is not None:
                print()  # Newline between different authors
            label = "FINAL" if event.type == "output" else "intermediate"
            print(f"[{label}] {author}: {update.text}", end="", flush=True)
            last_author = author
        else:
            print(update.text, end="", flush=True)

Orkestrasi Berurutan dengan Human-in-the-Loop

Orkestrasi berurutan mendukung interaksi manusia dalam lingkaran pengendali dengan dua cara: persetujuan alat untuk mengontrol panggilan alat sensitif, dan permintaan informasi dengan jeda setelah setiap respons agen untuk mengumpulkan umpan balik.

Persetujuan Alat dalam Alur Kerja Berurutan

Gunakan @tool(approval_mode="always_require") untuk menandai alat yang memerlukan persetujuan manusia sebelum eksekusi. Alur kerja menjeda dan menghasilkan request_info peristiwa saat agen mencoba menggunakan alat.

@tool(approval_mode="always_require")
def execute_database_query(query: str) -> str:
    return f"Query executed successfully: {query}"


database_agent = Agent(
    client=chat_client,
    name="DatabaseAgent",
    instructions="You are a database assistant.",
    tools=[execute_database_query],
)

workflow = SequentialBuilder(participants=[database_agent]).build()

Proses aliran peristiwa dan tangani permintaan persetujuan:

async def process_event_stream(stream):
    responses = {}
    async for event in stream:
        if event.type == "request_info" and event.data.type == "function_approval_request":
            responses[event.request_id] = event.data.to_function_approval_response(approved=True)
    return responses if responses else None

stream = workflow.run("Check the schema and update all pending orders", stream=True)

pending_responses = await process_event_stream(stream)
while pending_responses is not None:
    stream = workflow.run(stream=True, responses=pending_responses)
    pending_responses = await process_event_stream(stream)

Permintaan Info untuk Tanggapan Agen

Gunakan .with_request_info() untuk menjeda setelah agen tertentu merespons, memungkinkan input eksternal (seperti tinjauan manusia) sebelum agen berikutnya dimulai:

drafter = Agent(
    client=chat_client,
    name="drafter",
    instructions="You are a document drafter. Create a brief draft on the given topic.",
)

editor = Agent(
    client=chat_client,
    name="editor",
    instructions="You are an editor. Review and improve the draft. Incorporate any human feedback.",
)

finalizer = Agent(
    client=chat_client,
    name="finalizer",
    instructions="You are a finalizer. Create a polished final version.",
)

# Enable request info for the editor agent only
workflow = (
    SequentialBuilder(participants=[drafter, editor, finalizer])
    .with_request_info(agents=["editor"])
    .build()
)

async def process_event_stream(stream):
    responses = {}
    async for event in stream:
        if event.type == "request_info":
            responses[event.request_id] = AgentRequestInfoResponse.approve()
    return responses if responses else None

stream = workflow.run("Write a brief introduction to artificial intelligence.", stream=True)

pending_responses = await process_event_stream(stream)
while pending_responses is not None:
    stream = workflow.run(stream=True, responses=pending_responses)
    pending_responses = await process_event_stream(stream)

Konsep utama

• Konteks Bersama: Secara default, setiap agen menggunakan percakapan lengkap agen sebelumnya, termasuk pesan input dan respons
• Kontrol Konteks: Gunakan chain_only_agent_responses=True untuk mengonfigurasi agen agar hanya menggunakan pesan respons agen sebelumnya
• Output AgentResponse: Output terminal alur kerja adalah yang AgentResponse berisi respons agen terakhir (bukan percakapan lengkap)
• Order Matters: Agen-agen menjalankan secara ketat dalam urutan yang ditentukan dalam daftar participants
• Peserta Fleksibel: Anda dapat mencampur agen dan pelaksana kustom dalam urutan apa pun
• Kontrak Terminator Kustom: Pelaksana kustom yang digunakan sebagai peserta terakhir harus memanggil ctx.yield_output(AgentResponse(...)) untuk menghasilkan output terminal
• Keluaran Antara: Gunakan intermediate_output_from=[...] atau intermediate_output_from="all_other" untuk memunculkan kemajuan peserta sebagai event alur kerja antara, bukan hanya keluaran akhir peserta terakhir
• Persetujuan Alat: Gunakan @tool(approval_mode="always_require") untuk operasi sensitif yang memerlukan peninjauan manusia
• Permintaan Informasi: Gunakan .with_request_info(agents=[...]) untuk berhenti sejenak setelah agen tertentu demi umpan balik eksternal

Go dapat membangun alur kerja agen berurutan dengan workflow/agentworkflow. NewSequentialWorkflowBuilder menghosting setiap agen sebagai pelaksana alur kerja, menghubungkannya secara berurutan, dan menghasilkan batch pesan akhir sebagai output alur kerja.

Siapkan Konfigurasi Foundry

endpoint := os.Getenv("FOUNDRY_PROJECT_ENDPOINT")
model := cmp.Or(os.Getenv("FOUNDRY_MODEL"), "gpt-4o-mini")

token, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
    return err
}

Tentukan Agen Go Anda

Buat agen khusus yang akan berfungsi secara berurutan:

newTranslationAgent := func(language string) *agent.Agent {
    return foundryprovider.NewAgent(
        endpoint,
        token,
        foundryprovider.ModelDeployment(model),
        foundryprovider.AgentConfig{
            Instructions: fmt.Sprintf(
                "You are a translation assistant who only responds in %s. Respond to any input by outputting the name of the input language and then translating the input to %s.",
                language,
                language,
            ),
            Config: agent.Config{Name: language},
        },
    )
}

frenchAgent := newTranslationAgent("French")
spanishAgent := newTranslationAgent("Spanish")
englishAgent := newTranslationAgent("English")

Menyiapkan Orkestrasi Berurutan

wf, err := agentworkflow.NewSequentialWorkflowBuilder(
    frenchAgent,
    spanishAgent,
    englishAgent,
).
    WithName("translation-pipeline").
    Build()
if err != nil {
    return err
}

Jalankan Alur Kerja Berurutan

Jalankan alur kerja dan proses peristiwa output:

run, err := inproc.Default.RunStreaming(ctx, wf, []*message.Message{message.NewText("Hello, world!")})
if err != nil {
    return err
}
defer run.Close(ctx)

emitEvents := true
if err := run.SendMessage(ctx, workflow.TurnToken{EmitEvents: &emitEvents}); err != nil {
    return err
}

lastExecutorID := ""
for evt, err := range run.WatchStream(ctx) {
    if err != nil {
        return err
    }
    switch e := evt.(type) {
    case workflow.OutputEvent:
        switch value := e.Output.(type) {
        case *agent.ResponseUpdate:
            if e.ExecutorID != lastExecutorID {
                lastExecutorID = e.ExecutorID
                fmt.Printf("\n%s: ", e.ExecutorID)
            }
            fmt.Print(value.String())
        case []*message.Message:
            fmt.Println("\n===== Final Response =====")
            for _, msg := range value {
                fmt.Printf("%s: %s\n", msg.Role, msg.String())
            }
        }
    case workflow.ErrorEvent:
        return e.Error
    case workflow.ExecutorFailedEvent:
        return fmt.Errorf("executor %q failed: %w", e.ExecutorID, e.Error)
    }
}

Sampel Output

French: English detected. Bonjour, le monde !
Spanish: French detected. ¡Hola, mundo!
English: Spanish detected. Hello, world!

===== Final Response =====
assistant: Spanish detected. Hello, world!

Orkestrasi Berurutan dengan Human-in-the-Loop

Alur kerja berurutan dapat dijeda untuk persetujuan alat saat agen terhosting menggunakan alat yang memerlukan persetujuan. Bungkus alat dengan tool.ApprovalRequiredFunc, lalu dengarkan workflow.RequestInfoEvent dan tanggapi dengan ToolApprovalResponseContent.

Tentukan Agen dengan Alat yang Memerlukan Persetujuan

deployAgent := foundryprovider.NewAgent(
    endpoint,
    token,
    foundryprovider.ModelDeployment(model),
    foundryprovider.AgentConfig{
        Instructions: "You are a DevOps engineer. Check staging status first, then deploy to production.",
        Config: agent.Config{
            Name:  "DeployAgent",
            Tools: []tool.Tool{tool.ApprovalRequiredFunc(deployTool)},
        },
    },
)

verifyAgent := foundryprovider.NewAgent(
    endpoint,
    token,
    foundryprovider.ModelDeployment(model),
    foundryprovider.AgentConfig{
        Instructions: "You are a QA engineer. Verify that the deployment was successful and summarize the results.",
        Config:      agent.Config{Name: "VerifyAgent"},
    },
)

wf, err := agentworkflow.NewSequentialWorkflowBuilder(deployAgent, verifyAgent).
    WithName("deployment-pipeline").
    Build()
if err != nil {
    return err
}

Membangun dan Menjalankan dengan Penanganan Persetujuan

Menangani permintaan persetujuan di aliran peristiwa:

for evt, err := range run.WatchStream(ctx) {
    if err != nil {
        return err
    }

    requestEvent, ok := evt.(workflow.RequestInfoEvent)
    if !ok {
        continue
    }

    requestContent, ok := requestEvent.Request.Data.As(reflect.TypeFor[*message.ToolApprovalRequestContent]())
    if !ok {
        continue
    }

    approvalRequest := requestContent.(*message.ToolApprovalRequestContent)
    response, err := requestEvent.Request.CreateResponse(approvalRequest.CreateResponse(true, "approved"))
    if err != nil {
        return err
    }

    if err := run.SendResponse(ctx, response); err != nil {
        return err
    }
}

Tingkat Lanjut: Menggabungkan Agen dengan Eksekutor Kustom

Untuk alur campuran, agen host dengan agentworkflow.New dan menghubungkannya ke pelaksana kustom dengan workflow.NewBuilder:

writer := agentworkflow.New(writerAgent, agentworkflow.Config{})

summarizer := workflow.NewExecutor("Summarizer", func(messages []*message.Message) string {
    return summarizeMessages(messages)
}).Bind()

wf, err := workflow.NewBuilder(writer).
    AddEdge(writer, summarizer).
    WithOutputFrom(summarizer).
    Build()
if err != nil {
    return err
}

Mengontrol Konteks Antar Agen

NewSequentialWorkflowBuilder menggunakan konfigurasi agen yang dihosting default, di mana setiap agen hilir menerima pesan masuk dan pesan respons agen sebelumnya. Untuk hanya menautkan respons agen sebelumnya, atur WithChainOnlyAgentResponses(true):

wf, err := agentworkflow.NewSequentialWorkflowBuilder(frenchAgent, spanishAgent, englishAgent).
    WithChainOnlyAgentResponses(true).
    Build()
if err != nil {
    return err
}

Hasil Sementara

Secara default, NewSequentialWorkflowBuilder memancarkan output setiap peserta sebagai output alur kerja menengah dan memancarkan batch pesan akhir sebagai output terminal. Untuk secara eksplisit memilih output peserta yang Anda inginkan, gabungkan WithIntermediateOutputFrom dan WithOutputFrom:

wf, err := agentworkflow.NewSequentialWorkflowBuilder(frenchAgent, spanishAgent, englishAgent).
    WithIntermediateOutputFrom(frenchAgent, spanishAgent).
    WithOutputFrom(englishAgent).
    Build()
if err != nil {
    return err
}

Gunakan OutputEvent.IsIntermediate() untuk membedakan output peserta menengah dari output terminal.

Konsep utama

• Pemrosesan Berurutan: Setiap agen atau eksekutor memproses output dari langkah sebelumnya secara berurutan.
• alur kerja agen. NewSequentialWorkflowBuilder(): Membuat alur kerja dari kumpulan agen.
• Agen yang Dihosting: agentworkflow.New mengekspos opsi konfigurasi agen untuk penerusan pesan, penetapan ulang peran, peristiwa pembaruan, dan penyadapan permintaan.
• Pelaksana Kustom: Alur manual workflow.NewBuilder dapat mencampur agen yang dihosting dan pelaksana deterministik.
• Persetujuan Alat: Alat yang memerlukan persetujuan menjeda alur kerja dan menghasilkan nilai RequestInfoEvent yang berisi ToolApprovalRequestContent.
• Output Perantara: WithIntermediateOutputFrom menandai output peserta yang dipilih dengan workflow.OutputTagIntermediate.