Microsoft Agent Framework-arbetsflöden – Använda arbetsflöden som agenter

Kravspecifikation

Om du vill använda ett arbetsflöde som agent måste arbetsflödets startexekutor kunna hantera IEnumerable<ChatMessage> som indata. Detta uppfylls automatiskt när du använder agentbaserade utförare som skapats med AsAIAgent.

Skapa en arbetsflödesagent

AsAIAgent() Använd tilläggsmetoden för att konvertera alla kompatibla arbetsflöden till en agent:

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

// Create agents
AIAgent researchAgent = chatClient.AsAIAgent("You are a researcher. Research and gather information on the given topic.");
AIAgent writerAgent = chatClient.AsAIAgent("You are a writer. Write clear, engaging content based on research.");
AIAgent reviewerAgent = chatClient.AsAIAgent("You are a reviewer. Review the content and provide a final polished version.");

// Build a sequential workflow
var workflow = new WorkflowBuilder(researchAgent)
    .AddEdge(researchAgent, writerAgent)
    .AddEdge(writerAgent, reviewerAgent)
    .Build();

// Convert the workflow to an agent
AIAgent workflowAgent = workflow.AsAIAgent(
    id: "content-pipeline",
    name: "Content Pipeline Agent",
    description: "A multi-agent workflow that researches, writes, and reviews content"
);

AsAIAgent parametrar

Använda arbetsflödesagenter

Skapa en session

Varje konversation med en arbetsflödesagent kräver en session för att hantera tillstånd:

// Create a new session for the conversation
AgentSession session = await workflowAgent.CreateSessionAsync();

Körning utan direktuppspelning

För enkla användningsfall där du vill ha ett fullständigt svar:

var messages = new List<ChatMessage>
{
    new(ChatRole.User, "Write an article about renewable energy trends in 2025")
};

AgentResponse response = await workflowAgent.RunAsync(messages, session);

foreach (ChatMessage message in response.Messages)
{
    Console.WriteLine($"{message.AuthorName}: {message.Text}");
}

Körning av direktuppspelning

För realtidsuppdateringar när arbetsflödet körs:

var messages = new List<ChatMessage>
{
    new(ChatRole.User, "Write an article about renewable energy trends in 2025")
};

await foreach (AgentResponseUpdate update in workflowAgent.RunStreamingAsync(messages, session))
{
    // Process streaming updates from each agent in the workflow
    if (!string.IsNullOrEmpty(update.Text))
    {
        Console.Write(update.Text);
    }
}

Hantera externa indatabegäranden

När ett arbetsflöde innehåller utförare som begär externa indata (med RequestInfoExecutor), visas dessa begäranden som funktionsanrop i agentsvaret:

await foreach (AgentResponseUpdate update in workflowAgent.RunStreamingAsync(messages, session))
{
    // Check for function call requests
    foreach (AIContent content in update.Contents)
    {
        if (content is FunctionCallContent functionCall)
        {
            // Handle the external input request
            Console.WriteLine($"Workflow requests input: {functionCall.Name}");
            Console.WriteLine($"Request data: {functionCall.Arguments}");

            // Provide the response in the next message
        }
    }
}

Seriellisering och återupptagande av sessioner

Arbetsflödesagentsessioner kan serialiseras för beständighet och återupptas senare:

// Serialize the session state
JsonElement serializedSession = await workflowAgent.SerializeSessionAsync(session);

// Store serializedSession to your persistence layer...

// Later, resume the session
AgentSession resumedSession = await workflowAgent.DeserializeSessionAsync(serializedSession);

// Continue the conversation
await foreach (var update in workflowAgent.RunStreamingAsync(newMessages, resumedSession))
{
    Console.Write(update.Text);
}

Kravspecifikation

Om du vill använda ett arbetsflöde som agent måste arbetsflödets startexekutor kunna hantera meddelandeindata. Detta uppfylls automatiskt när du använder Agent eller agentbaserade utförare.

Skapa en arbetsflödesagent

Anropa as_agent() alla kompatibla arbetsflöden för att konvertera det till en agent:

from agent_framework.foundry import FoundryChatClient
from agent_framework.orchestrations import SequentialBuilder
from azure.identity import AzureCliCredential

# Create your chat client and agents
client = FoundryChatClient(
    project_endpoint="<your-endpoint>",
    model="<your-deployment>",
    credential=AzureCliCredential(),
)

researcher = client.as_agent(
    name="Researcher",
    instructions="Research and gather information on the given topic.",
)

writer = client.as_agent(
    name="Writer",
    instructions="Write clear, engaging content based on research.",
)

# Build a sequential workflow
workflow = SequentialBuilder(participants=[researcher, writer]).build()

# Convert the workflow to an agent
workflow_agent = workflow.as_agent(name="Content Pipeline Agent")

as_agent parametrar

Använda arbetsflödesagenter

Skapa en session

Du kan också skapa en session för att hantera konversationstillstånd över flera varv:

# Create a new session for the conversation
session = await workflow_agent.create_session()

Körning utan direktuppspelning

För enkla användningsfall där du vill ha ett fullständigt svar:

# You can pass a plain string as input
response = await workflow_agent.run("Write an article about AI trends")

for message in response.messages:
    print(f"{message.author_name}: {message.text}")

Körning av direktuppspelning

För realtidsuppdateringar när arbetsflödet körs:

async for update in workflow_agent.run(
    "Write an article about AI trends",
    stream=True,
):
    if update.text:
        print(update.text, end="", flush=True)

Hantera externa indatabegäranden

När ett arbetsflöde innehåller utförare som begär externa indata (med hjälp av request_info) visas dessa begäranden som funktionsanrop i agentsvaret. Funktionsanropet använder namnet WorkflowAgent.REQUEST_INFO_FUNCTION_NAME:

from agent_framework import Content, Message, WorkflowAgent

response = await workflow_agent.run("Process my request")

# Look for function calls in the response
human_review_function_call = None
for message in response.messages:
    for content in message.contents:
        if content.name == WorkflowAgent.REQUEST_INFO_FUNCTION_NAME:
            human_review_function_call = content

Tillhandahålla svar på väntande begäranden

Om du vill fortsätta arbetsflödeskörningen efter en extern indatabegäran skapar du ett funktionsresultat och skickar tillbaka det:

if human_review_function_call:
    # Parse the request arguments
    request = WorkflowAgent.RequestInfoFunctionArgs.from_json(
        human_review_function_call.arguments
    )

    # Create a response (your custom response type)
    result_data = MyResponseType(approved=True, feedback="Looks good")

    # Create the function call result
    function_result = Content.from_function_result(
        call_id=human_review_function_call.call_id,
        result=result_data,
    )

    # Send the response back to continue the workflow
    response = await workflow_agent.run(Message("tool", [function_result]))

Fullständigt exempel

Här är ett fullständigt exempel som visar en arbetsflödesagent med strömmande utdata:

import asyncio
import os

from agent_framework.foundry import FoundryChatClient
from agent_framework.orchestrations import SequentialBuilder
from azure.identity import AzureCliCredential


async def main():
    # Set up the chat client
    client = FoundryChatClient(
        project_endpoint=os.environ["FOUNDRY_PROJECT_ENDPOINT"],
        model=os.environ["FOUNDRY_MODEL"],
        credential=AzureCliCredential(),
    )

    # Create specialized agents
    researcher = client.as_agent(
        name="Researcher",
        instructions="Research the given topic and provide key facts.",
    )

    writer = client.as_agent(
        name="Writer",
        instructions="Write engaging content based on the research provided.",
    )

    reviewer = client.as_agent(
        name="Reviewer",
        instructions="Review the content and provide a final polished version.",
    )

    # Build a sequential workflow
    workflow = SequentialBuilder(participants=[researcher, writer, reviewer]).build()

    # Convert to a workflow agent
    workflow_agent = workflow.as_agent(name="Content Creation Pipeline")

    # Run the workflow
    print("Starting workflow...")
    print("=" * 60)

    current_author = None
    async for update in workflow_agent.run(
        "Write about quantum computing",
        stream=True,
    ):
        # Show when different agents are responding
        if update.author_name and update.author_name != current_author:
            if current_author:
                print("\n" + "-" * 40)
            print(f"\n[{update.author_name}]:")
            current_author = update.author_name

        if update.text:
            print(update.text, end="", flush=True)

    print("\n" + "=" * 60)
    print("Workflow completed!")


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

Att förstå händelsekonvertering

När ett arbetsflöde körs som en agent konverteras arbetsflödeshändelser till agentsvar. Typen av svar beror på hur du anropar run():

• run(): Returnerar ett AgentResponse innehållande det fullständiga resultatet när arbetsflödet har slutförts
• run(..., stream=True): Returnerar en asynkron iterbar mängd AgentResponseUpdate objekt när arbetsflödet körs, vilket ger realtidsuppdateringar

Under körning mappas interna arbetsflödeshändelser till agentsvar på följande sätt:

Med den här konverteringen kan du använda standardagentgränssnittet samtidigt som du har åtkomst till detaljerad arbetsflödesinformation när det behövs.