Beständigt tillägg

Durable-tillägget för Microsoft Agent Framework ger varaktig körning till agenter, orkestreringar för flera agenter och Microsoft Agent Framework-arbetsflöden. Du kan använda den för att bevara agentsessioner, orkestrering av kontrollpunkter och arbetsflödesförlopp, återställa från fel och skala arbete mellan distribuerade värdar utan att ändra din kärnagentlogik.

Tillägget stöder två värdmodeller i C# och Python:

  • Azure Functions för hanterad, serverlös värd med Azure Functions programmeringsmodell.
  • Bring-your-own-compute/self-hosted för att köra hållbara agenter och arbetsflöden i din egen arbetsprocess, tjänst, container, Kubernetes-miljö eller befintlig appinfrastruktur.

Note

Den här guiden beskriver C# och Python durable extension hosting. För Go-värd, se A2A-värd och Agent Framework Go-lagringsplatsen.

Overview

Varaktiga agenter kombinerar Agent Framework-programmeringsmodellen med durable task-infrastrukturen, till exempel Durable Task Scheduler, för att skapa agenter som:

  • Spara tillstånd automatiskt mellan begäranden och arbetskörningar
  • Återuppta efter fel utan att förlora konversationskontexten eller upprepa slutfört arbete
  • Skala över distribuerade, tillståndslösa arbetare baserat på efterfrågan
  • Samordna arbetsflöden för flera agenter med tillförlitliga körningsgarantier
  • Checkpoint Agent Framework-arbetsflöden som skapats med den grafbaserade arbetsflödesmodellen
  • Pausa för mänsklig indata eller externa händelser utan att använda beräknings- eller modelltoken i väntan
  • Återuppta strömmad leverans när den konfigureras med en stream broker, till exempel Redis; bekräfta varaktigt slutförande separat
  • Hantera sessionslivscykel med rensning av sessionstid till live (TTL) och instrumentpanelsbaserad övervakning

När du ska använda beständiga agenter

Välj hållbara agenter när du behöver:

  • Beständiga konversationstillstånd: Agentsessioner överlever processkrascher, omstarter och utskalningshändelser
  • Komplexa orkestreringar: Samordna flera agenter med deterministiska, tillförlitliga arbetsflöden som kan köras i dagar eller veckor
  • Händelsedriven orkestrering: Integrera med utlösare, köer, webhooks, timers eller befintliga programhändelser
  • Automatiskt konversationstillstånd: Agentkonversationshistoriken hanteras automatiskt och sparas utan att det krävs explicit tillståndshantering i koden
  • Durable Agent Framework-arbetsflöden: Gör grafbaserade Microsoft Agent Framework-arbetsflöden hållbara så att varje steg kan kontrolleras och återupptas
  • Långlivade sessioner: Håll användbara konversationer tillgängliga när du använder rensning av sessionstid till live (TTL) för att ta bort inaktiva sessioner automatiskt
  • Realtidssvar: Leverera inkrementella tokenutdata med asynkron återanslutning, samtidigt som du kontrollerar det varaktiga resultatet separat

Den här värdmetoden skiljer sig från hanterad tjänstbaserad agentvärd (till exempel Foundry Agent Service), som tillhandahåller fullständigt hanterad infrastruktur utan att du behöver distribuera eller hantera arbetsvärdar. Varaktiga agenter är idealiska när du behöver flexibiliteten i kod-första distributionen i kombination med beständig tillståndshantering.

Välj en värdmodell

Värdmodell Välj den när du behöver
Azure-funktioner En hanterad, serverlös värdmodell; inbyggd utskalning och skalning till noll. Azure Functions utlösare och bindningar; HTTP-slutpunkter som genereras av programmeringsmodellen Functions; MCP-serverutlösaren. och minimal hantering av värdinfrastruktur.
Bring-your-own-compute/self-hosted Mer kontroll över värdprocessen, distributionsmiljön, körningslivscykeln, infrastruktur, nätverk, autentisering eller integrering med en befintlig app eller tjänst. Använd den här modellen för containrar, Kubernetes, långvariga arbetare, konsolappar, anpassade tjänster eller icke-Functions-värdmiljöer.

När agenterna finns i Azure Functions Flex Consumption-värdplanen kan de skala till tusentals instanser eller till noll instanser när de inte används, så att du bara betalar för den beräkning du behöver. I scenarier med egen värd bearbetar dina egna värdkontroller livslängd, skalning, nätverk och distribution.

Komma igång

Använd installationskommandona för värdmodellen nedan. Behåll förhandsversionsalternativen som visas för förhandsversionspaket. Fullständiga program finns i källan och exemplen.

Dokumentation om källgrenar kan beskriva funktioner som inte är tillgängliga i publicerade paket ännu. Använd endast konfigurations- och migreringssteg för funktioner som ingår i den installerade versionen.

Important

Innan du uppgraderar en befintlig distribution granskar du distributions- och schemamigreringen. Peka inte en uppgraderad arbetare på gamla arbetsflödeshistoriker utan att kontrollera omspelningskompatibiliteten.

I ett .NET projekt väljer du paketuppsättningen för din värdmodell.

För Azure Functions värd lägger du till Azure Functions integrationspaketet och Functions Worker-paketen.

dotnet add package Microsoft.Agents.AI.Foundry --prerelease
dotnet add package Microsoft.Agents.AI.Hosting.AzureFunctions --prerelease

Note

Använd functions worker-, DurableTask-arbetartillägget och AzureManaged Worker-tilläggsversionerna som deklareras av agenttilläggets beroenden. Ta bort direktpaketreferenser som nedgraderar dessa beroenden. Se referenserna för .NET beroende. Schema-v2-uppgraderingar sida vid sida kräver också filtrering av arbetsobjekt. se distribution och schemamigrering.

För bring-your-own-compute-värd lägger du till baspaketet durable task integration och Durable Task Scheduler worker/client packages som används av värden:

dotnet add package Microsoft.Agents.AI.Foundry --prerelease
dotnet add package Microsoft.Agents.AI.DurableTask --prerelease
dotnet add package Microsoft.DurableTask.Client.AzureManaged
dotnet add package Microsoft.DurableTask.Worker.AzureManaged
dotnet add package Microsoft.Extensions.Hosting

I ett Python projekt väljer du paketet för din värdmodell. Python värdar kräver en explicit distributionsstrategi.

För Azure Functions värd använder du Python 3.13 eller senare och installerar Azure Functions integrationspaketet. Följande kommandon installerar även den Azure OpenAI-klienten som används i den här guiden.

pip install agent-framework-azurefunctions agent-framework-openai azure-identity --pre

För bring-your-own-compute-värd använder du Python 3.10 eller senare och installerar durable task-integreringspaketet.

pip install agent-framework-durabletask agent-framework-openai azure-identity --pre

För en ny isolerad aktivitetshubb med uppgraderade arbetare och klienter anger du DURABLE_AGENTS_DEPLOYMENT_MODE=isolated_v2 innan du startar någon av värddatorerna. För en befintlig hubb väljer du migreringsstrategin i stället för att använda den här inställningen blint. Inställningen bekräftar isolering. Det identifierar inte andra arbetare eller gör gamla historier kompatibla.

Azure Functions värd

Med Durable-tillägget kan du distribuera och vara värd för Microsoft Agent Framework-agenter i Azure Functions med inbyggda HTTP-slutpunkter och orkestreringsbaserat anrop. Azure Functions tillhandahåller händelsedrivna priser med betala per anrop med automatisk skalning och minimal infrastrukturhantering.

När du konfigurerar en varaktig agent i Azure Functions skapar tillägget automatiskt HTTP-slutpunkter för din agent och hanterar den underliggande infrastrukturen för lagring av konversationstillstånd, hantering av samtidiga begäranden och samordning av arbetsflöden för flera agenter. Den Azure Functions värdintegrering ger också Funktioner-specifika bekvämligheter, till exempel genererade REST-API:er för att skicka meddelanden, kontrollera status och hantera sessioner, plus utlösare som MCP-serverutlösaren för värdagenter som MCP-servrar utan att skriva utlösarlim.

using System;
using Azure.AI.Projects;
using Azure.Identity;
using Microsoft.Agents.AI;
using Microsoft.Agents.AI.Hosting.AzureFunctions;
using Microsoft.Azure.Functions.Worker.Builder;
using Microsoft.Extensions.Hosting;

var endpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT");
var deploymentName = Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOYMENT") ?? "gpt-4o-mini";

// Create an AI agent following the standard Microsoft Agent Framework pattern
AIAgent agent = new AIProjectClient(new Uri(endpoint), new DefaultAzureCredential())
    .AsAIAgent(
        model: deploymentName,
        instructions: "You are good at telling jokes.",
        name: "Joker");

// Configure the function app to host the agent with durable thread management
// This automatically creates HTTP endpoints and manages state persistence
using IHost app = FunctionsApplication
    .CreateBuilder(args)
    .ConfigureFunctionsWebApplication()
    .ConfigureDurableAgents(options =>
        options.AddAIAgent(agent)
    )
    .Build();
app.Run();

Varning

DefaultAzureCredential är praktiskt för utveckling men kräver noggrant övervägande i produktion. I produktion bör du överväga att använda en specifik autentiseringsuppgift (t.ex. ManagedIdentityCredential) för att undvika problem med svarstid, oavsiktlig avsökning av autentiseringsuppgifter och potentiella säkerhetsrisker från reservmekanismer.

import os
from agent_framework_azurefunctions import AgentFunctionApp
from agent_framework.openai import OpenAIChatCompletionClient
from azure.identity import DefaultAzureCredential

endpoint = os.getenv("AZURE_OPENAI_ENDPOINT")
deployment_name = os.getenv("AZURE_OPENAI_DEPLOYMENT", "gpt-4o-mini")
api_version = os.getenv("AZURE_OPENAI_API_VERSION")

# Create an AI agent following the standard Microsoft Agent Framework pattern
agent = OpenAIChatCompletionClient(
    azure_endpoint=endpoint,
    model=deployment_name,
    api_version=api_version,
    credential=DefaultAzureCredential()
).as_agent(
    instructions="You are good at telling jokes.",
    name="Joker"
)

# Configure the function app to host the agent with durable thread management
# This automatically creates HTTP endpoints and manages state persistence
app = AgentFunctionApp(agents=[agent])

Bring-your-own-compute/self-hosted hosting

Använd bring-your-own-compute-värd när du vill ha funktionerna i Durable Extension utan att använda Azure Functions programmeringsmodell. I den här modellen startar din process en Durable Task Worker, registrerar varaktiga agenter eller arbetsflöden och ansluter till en Durable Task Scheduler-serverdel. Klientkoden kan köras i samma process eller i en separat tjänst.

Lokalt installerade arbetare använder samma grundläggande funktioner för Durable Extension som Azure Functions värd: kontrollpunkter och återupptagande, deterministisk agentorkestrering, hållbara Agent Framework-arbetsflöden, väntetider för människor i loopen, tillförlitlig strömning, rensning av inaktivitetssessioner, synlighet på instrumentpanelen och distribuerad körning över tillståndslösa arbetsinstanser. Värden ansvarar för att exponera sina egna API:er, livscykelhantering, nätverk, autentisering och distributionsmodell.

Konfigurera värden med basintegreringspaketet för durable task. Använd ConfigureDurableAgents för varaktiga agenter och ConfigureDurableWorkflows för grafbaserade Microsoft Agent Framework-arbetsflöden.

string connectionString = Environment.GetEnvironmentVariable("DURABLE_TASK_SCHEDULER_CONNECTION_STRING")
    ?? "Endpoint=http://localhost:8080;TaskHub=default;Authentication=None";

IHost host = Host.CreateDefaultBuilder(args)
    .ConfigureServices(services =>
    {
        services.ConfigureDurableAgents(
            options => options.AddAIAgent(agent),
            workerBuilder: builder => builder.UseDurableTaskScheduler(connectionString),
            clientBuilder: builder => builder.UseDurableTaskScheduler(connectionString));
    })
    .Build();

await host.StartAsync();

Se konsolexemplen .NET Durable Agents och .NET Durable Workflows för körbara exempel med egen värd.

Använd integrationspaketet durable task för att köra en arbetsprocess som registrerar agenter och lyssnar efter begäranden. Klientkoden kan ansluta till samma Durable Task Scheduler-aktivitetshubb från en annan process.

from agent_framework_durabletask import DurableAIAgentWorker
from durabletask.azuremanaged.worker import DurableTaskSchedulerWorker

worker = DurableTaskSchedulerWorker(
    host_address="http://localhost:8080",
    secure_channel=False,
    taskhub="default",
)

agent_worker = DurableAIAgentWorker(worker)
agent_worker.add_agent(agent)

worker.start()

Se exemplen Python Durable Task för arbetsklientexempel, inklusive värdtjänster med en agent, routning med flera agenter, tillförlitlig strömning, orkestreringslänkning, samtidighet, villkor och mönster för människa i loopen.

Durable Agent Framework-arbetsflöden

Hållbarheten är inte begränsad till hållbara orkestreringar. Microsoft Agent Framework-arbetsflöden som skapats med den grafbaserade arbetsflödesmodellen kan också göras hållbara. Arbetsflödet durable extension checkpoints execution so completed executor and agent steps upprepas inte efter en processomstart eller ett fel.

Använd varaktiga orkestreringar när du vill ha imperativ samordning med kodbaserad förgrening, timers, aktiviteter och externa händelser. Använd varaktiga Agent Framework-arbetsflöden när du vill ha ett deklarativt diagram över exekutorer och agenter med skrivskyddad routning, utfläkt/infläkt, villkorliga kanter, arbetsflödeshändelser, delat tillstånd, underarbetsflöden eller portar för mänsklig in-the-loop-begäran.

Note

Durable Agent Framework-arbetsflöden skiljer sig från kontrollpunktslagring i standardarbetsflöden. Kontrollpunktslagring hjälper dig att återuppta en arbetsflödeskörning i Agent Framework-körningen. Durable-tillägget kör arbetsflödet på durable task-infrastrukturen så att arbetsflödets förlopp är kontrollpunkter och återställs för distribuerade varaktiga arbetare. Standardkontrollpunkter för arbetsflöden finns i Kontrollpunkter och återuppta.

Registrera grafbaserade arbetsflöden med ConfigureDurableWorkflows för appar med egen värd eller ConfigureDurableWorkflows på Functions-appverktyget för Azure Functions värd.

Se .NET Durable Workflows Azure Functions exempel och .NET Durable Workflows-konsolexempel.

Hållbara arbetsflödesexempel är tillgängliga för Azure Functions värdtjänster, inklusive delat tillstånd, inget delat tillstånd, parallell arbetsflödeskörning och arbetsflöden för människor i loopen. Python stöder även grafbaserade arbetsflöden på en fristående durable task worker.

Se exemplen Python Azure Functions för exempel på varaktig agent, orkestrering, MCP-server och arbetsflöde.

Information om grafkörning med egen värd finns i det fristående Python arbetsflödesexemplet.

Samples

Språk Värdmodell Varaktiga agenter och orkestreringar Diagrambaserade arbetsflöden
C# Azure Functions .NET agentexempel .NET arbetsflödesexempel
C# Self-hosted .NET konsolagentexempel .NET exempel på konsolarbetsflöde
Python Azure Functions Python Functions-exempel Python Functions-arbetsflödesexempel
Python Self-hosted Python arbets- och klientexempel Python fristående arbetsflöde

De här exemplen visar stöd, inte identiska API-kontrakt mellan olika språk. Functions genererar HTTP-slutpunkter; program med egen värd implementerar och skyddar sina egna API:er.

Tillståndskänsliga agenttrådar med konversationshistorik

Agenter underhåller beständiga sessioner som överlever över flera interaktioner. Varje session har ett unikt sessions-ID och lagrar konversationstillstånd i varaktig lagring som hanteras av durable task-infrastrukturen, till exempel Durable Task Scheduler.

Det här mönstret möjliggör konversationskontinuitet där agenttillstånd bevaras genom processkrascher och omstarter, vilket gör att fullständig konversationshistorik kan upprätthållas mellan användartrådar. Den varaktiga lagringen säkerställer att även om en värdprocess startas om eller arbetet återupptas på en annan arbetsinstans fortsätter konversationen sömlöst där den slutade.

Konfigurera sessionsrensning, historikkvarhållning och resultatkvarhållning avsiktligt. Dessa principer har olika effekter. se tillståndslivscykel och kapacitet.

Följande Azure Functions exempel visar flera HTTP-begäranden till samma session. Båda språkintegreringarna returnerar x-ms-session-id och accepterar den kanoniska frågeparametern sessionId . Behandla det returnerade ID:t som ogenomskinlig: exemplet visar en .NET schema-v2-entitetsadress, medan Python sessionsformatering beror på distributionsstrategin. I appar med egen värd använder du klient-API:erna för Durable Task från din egen process eller tjänst.

# First interaction - start a new session
curl -i -X POST https://your-function-app.azurewebsites.net/api/agents/Joker/run \
  -H "Content-Type: text/plain" \
  -d "Tell me a joke about pirates"

# Response includes session ID in x-ms-session-id header and joke as plain text
# HTTP/1.1 200 OK
# Content-Type: text/plain
# x-ms-session-id: @dafx-v2-joker@263fa373-fa01-4705-abf2-5a114c2bb87d
#
# Why don't pirates shower before they walk the plank? Because they'll just wash up on shore later!

# Second interaction - reuse the exact session ID returned by the first request
curl -X POST "https://your-function-app.azurewebsites.net/api/agents/Joker/run?sessionId=@dafx-v2-joker@263fa373-fa01-4705-abf2-5a114c2bb87d" \
  -H "Content-Type: text/plain" \
  -d "Tell me another one about the same topic"

# Agent remembers the pirate context from the first message and responds with plain text
# What's a pirate's favorite letter? You'd think it's R, but it's actually the C!

Agenttillståndet hålls kvar i varaktig lagring, vilket möjliggör körning i distribuerad form över flera instanser. Varje instans kan återuppta agentens körning efter avbrott eller fel, vilket säkerställer en kontinuerlig drift.

Använd sessionId och waitForResponse i nya AGENT HTTP-klienter. thread_id är ett inaktuellt begärandealias, inte svarshuvudet som ska avbildas. För Python JSON-svar läser sessionId du och correlationId. Se HTTP API-migreringsguiden för alias och konflikthantering.

Bekräfta varaktigt slutförande

För genererade .NET Functions-agentslutpunkter tolkar du slutförandet på följande sätt:

HTTP-statuskod Meaning
202 Accepted Dispatch accepteras. Körningen bekräftas inte.
200 OK Ett bekräftat lyckat resultat är tillgängligt.
500 Internal Server Error Ett bekräftat terminalfel som stöds returneras. Skilja detta från vanliga värd- eller transportfel.
410 Gone Slutförande är känt, men resultatet är inte tillgängligt. Det behållna resultatet kan vara succeeded eller failed. Det här är inte nödvändigtvis en misslyckad körning eller bara resultatets förfallodatum.

Läs x-ms-durable-outcome när ett slutförande inte har något tillgängligt resultat. Behandla 410 inte som väntande, härled inte ett resultat från konversationshistoriken eller skicka automatiskt igen med en ny identitet. JSON-anropare använder sträng status och numeriskt statusCode. Det tidigare status_code fältet är ett tillfälligt kompatibilitetsalias.

Python Functions särskiljer också tillgängliga lyckade, behållna misslyckade resultat och otillgängliga slutförda resultat. Dess felkuvert och SDK-alternativ är inte identiska med .NET. Se .NET slutförandekontrakt och Python HTTP-kontrakt.

Dessa statusar beskriver agentslutpunkter. API:et för Durable Functions orkestreringshantering har ett eget statussvar och avsökningskontrakt.

Tillförlitlig direktuppspelning

Durable Extension stöder tillförlitlig direktuppspelning för program som behöver tokenleverans i realtid tillsammans med beständig agentkörning. Direktuppspelning kan användas med kärntillägget i båda värdmodellerna, men distribuerade värdar behöver en tillförlitlig stream broker, till exempel Redis, så att klienter kan återuppta läsningen av kvarhållna tokenströmmar efter återanslutningar eller arbetsändringar, med förbehåll för koordinatorns beständighets- och kvarhållningsinställningar.

Använd tillförlitlig direktuppspelning när användarupplevelsen är beroende av inkrementella svar, men arbetsbelastningen behöver fortfarande varaktig körningssemantik. Dataströmsavslutningen bekräftar inte i sig själv att agentens resultat och tillstånd har bevarats korrekt. kontrollera det auktoritativa varaktiga resultatet separat. Körbara exempel finns i Python Durable Task-exempel, som innehåller tillförlitliga strömningsmönster.

Deterministiska orkestreringar för flera agenter

Durable Extension har stöd för att skapa deterministiska arbetsflöden som samordnar flera agenter med hjälp av durable task-orkestreringar. I Azure Functions använder dessa Durable Functions orkestreringar. I bring-your-own-compute-värdar körs de via durable task worker och klienten som du konfigurerar.

Orkestreringar är kodbaserade arbetsflöden som samordnar flera åtgärder (till exempel agentanrop, externa API-anrop eller timers) på ett tillförlitligt sätt. Deterministisk innebär att orkestreringskoden körs på samma sätt när den spelas upp efter ett fel, vilket gör arbetsflöden tillförlitliga och debuggable – när du spelar upp en orkestreringshistorik kan du se exakt vad som hände i varje steg.

Orkestreringar körs tillförlitligt, överlever fel mellan agentanropen och tillhandahåller förutsägbara och upprepbara processer. Detta gör dem idealiska för komplexa scenarier med flera agenter där du behöver garanterad exekveringsordning och feltolerans.

Varaktiga kontrollpunkter gör inte verktyg eller externa skrivningar transaktionella eller exakt en gång. Gör aktivitets- och verktygs sidoeffekter idempotent och definiera återförsöksgränser. Ett fel efter en extern skrivning men innan en varaktig incheckning kan orsaka att åtgärden körs igen.

Sekventiella orkestreringar

I det sekventiella multiagentmönstret körs specialiserade agenter i en specifik ordning, där varje agents utdata kan påverka nästa agentkörning. Det här mönstret stöder villkorsstyrd logik och förgrening baserat på agentsvar.

När du använder agenter i orkestreringar måste du använda API:et context.GetAgent() för att hämta en DurableAIAgent instans, vilket är en särskild underklass av standardtypen AIAgent som omsluter en av dina registrerade agenter. Omslutningen DurableAIAgent säkerställer att agentanrop spåras korrekt och kontrollpunktas av det hållbara orkestreringsramverket.

using Microsoft.Azure.Functions.Worker;
using Microsoft.DurableTask;
using Microsoft.Agents.AI.DurableTask;

[Function(nameof(SpamDetectionOrchestration))]
public static async Task<string> SpamDetectionOrchestration(
    [OrchestrationTrigger] TaskOrchestrationContext context)
{
    Email email = context.GetInput<Email>();

    // Check if the email is spam
    DurableAIAgent spamDetectionAgent = context.GetAgent("SpamDetectionAgent");
    AgentSession spamSession = await spamDetectionAgent.CreateSessionAsync();

    AgentResponse<DetectionResult> spamDetectionResponse = await spamDetectionAgent.RunAsync<DetectionResult>(
        message: $"Analyze this email for spam: {email.EmailContent}",
        session: spamSession);
    DetectionResult result = spamDetectionResponse.Result;

    if (result.IsSpam)
    {
        return await context.CallActivityAsync<string>(nameof(HandleSpamEmail), result.Reason);
    }

    // Generate response for legitimate email
    DurableAIAgent emailAssistantAgent = context.GetAgent("EmailAssistantAgent");
    AgentSession emailSession = await emailAssistantAgent.CreateSessionAsync();

    AgentResponse<EmailResponse> emailAssistantResponse = await emailAssistantAgent.RunAsync<EmailResponse>(
        message: $"Draft a professional response to: {email.EmailContent}",
        session: emailSession);

    return await context.CallActivityAsync<string>(nameof(SendEmail), emailAssistantResponse.Result.Response);
}

När du använder agenter i orkestreringar måste du använda app.get_agent()-metoden för att hämta en hållbar agent-instans, som är ett speciellt omslag runt en av dina registrerade agenter. Den hållbara agentomslutningen säkerställer att agentanrop spåras korrekt och kontrollpunkteras av det tåliga orkestreringsramverket.

from durabletask.task import OrchestrationContext
from agent_framework_azurefunctions import AgentFunctionApp
from pydantic import BaseModel

class SpamDetectionResult(BaseModel):
    is_spam: bool
    reason: str

class EmailResponse(BaseModel):
    response: str

app = AgentFunctionApp(agents=[spam_detection_agent, email_assistant_agent])

@app.orchestration_trigger(context_name="context")
def spam_detection_orchestration(context: OrchestrationContext, email: dict):
    # Check if the email is spam
    spam_agent = app.get_agent(context, "SpamDetectionAgent")
    spam_thread = spam_agent.create_session()

    spam_result_raw = yield spam_agent.run(
        messages=f"Analyze this email for spam: {email['content']}",
        session=spam_thread,
        options={"response_format": SpamDetectionResult},
    )
    spam_result = SpamDetectionResult.model_validate(spam_result_raw.value)

    if spam_result.is_spam:
        result = yield context.call_activity("handle_spam_email", input=spam_result.reason)
        return result

    # Generate response for legitimate email
    email_agent = app.get_agent(context, "EmailAssistantAgent")
    email_thread = email_agent.create_session()

    email_response_raw = yield email_agent.run(
        messages=f"Draft a professional response to: {email['content']}",
        session=email_thread,
        options={"response_format": EmailResponse},
    )
    email_response = EmailResponse.model_validate(email_response_raw.value)

    result = yield context.call_activity("send_email", input=email_response.response)
    return result

Orkestreringar samordnar arbete mellan flera agenter och klarar av fel mellan agentanrop. Orkestreringskontexten innehåller metoder för att hämta och interagera med värdbaserade agenter inom orkestreringar.

Parallella orkestreringar

I det parallella multiagentmönstret kör du flera agenter samtidigt och aggregerar sedan deras resultat. Det här mönstret är användbart för att samla in olika perspektiv eller bearbeta oberoende underaktiviteter samtidigt.

using Microsoft.Azure.Functions.Worker;
using Microsoft.DurableTask;
using Microsoft.Agents.AI.DurableTask;

[Function(nameof(ResearchOrchestration))]
public static async Task<string> ResearchOrchestration(
    [OrchestrationTrigger] TaskOrchestrationContext context)
{
    string topic = context.GetInput<string>();

    // Execute multiple research agents in parallel
    DurableAIAgent technicalAgent = context.GetAgent("TechnicalResearchAgent");
    DurableAIAgent marketAgent = context.GetAgent("MarketResearchAgent");
    DurableAIAgent competitorAgent = context.GetAgent("CompetitorResearchAgent");

    // Start all agent runs concurrently
    Task<AgentResponse<TextResponse>> technicalTask = 
        technicalAgent.RunAsync<TextResponse>($"Research technical aspects of {topic}");
    Task<AgentResponse<TextResponse>> marketTask = 
        marketAgent.RunAsync<TextResponse>($"Research market trends for {topic}");
    Task<AgentResponse<TextResponse>> competitorTask = 
        competitorAgent.RunAsync<TextResponse>($"Research competitors in {topic}");

    // Wait for all tasks to complete
    await Task.WhenAll(technicalTask, marketTask, competitorTask);

    // Aggregate results
    string allResearch = string.Join("\n\n", 
        technicalTask.Result.Result.Text,
        marketTask.Result.Result.Text,
        competitorTask.Result.Result.Text);

    DurableAIAgent summaryAgent = context.GetAgent("SummaryAgent");
    AgentResponse<TextResponse> summaryResponse = 
        await summaryAgent.RunAsync<TextResponse>($"Summarize this research:\n{allResearch}");

    return summaryResponse.Result.Text;
}

from durabletask.task import OrchestrationContext, when_all
from agent_framework_azurefunctions import AgentFunctionApp

app = AgentFunctionApp(agents=[technical_agent, market_agent, competitor_agent, summary_agent])

@app.orchestration_trigger(context_name="context")
def research_orchestration(context: OrchestrationContext, topic: str):
    # Execute multiple research agents in parallel
    technical_agent = app.get_agent(context, "TechnicalResearchAgent")
    market_agent = app.get_agent(context, "MarketResearchAgent")
    competitor_agent = app.get_agent(context, "CompetitorResearchAgent")

    technical_task = technical_agent.run(messages=f"Research technical aspects of {topic}")
    market_task = market_agent.run(messages=f"Research market trends for {topic}")
    competitor_task = competitor_agent.run(messages=f"Research competitors in {topic}")

    # Wait for all tasks to complete
    results = yield when_all([technical_task, market_task, competitor_task])

    # Aggregate results
    all_research = "\n\n".join(r.text for r in results)

    summary_agent = app.get_agent(context, "SummaryAgent")
    summary = yield summary_agent.run(messages=f"Summarize this research:\n{all_research}")

    return summary.text

Den parallella körningen spåras med hjälp av en lista över arbetsuppgifter. Automatisk kontrollpunktshantering säkerställer att slutförda agentkörningar inte upprepas eller går förlorade om ett fel inträffar under aggregering.

Orkestreringar för människor i loopen

Deterministiska agentorkestreringar kan pausas för mänsklig indata, godkännande eller granskning utan att förbruka beräkningsresurser. Varaktig körning gör det möjligt för orkestreringar att vänta i dagar eller till och med veckor medan de väntar på mänskliga svar. I kombination med serverlös värd, spunnas alla beräkningsresurser ned under väntetiden, vilket eliminerar beräkningskostnader tills människan tillhandahåller sina indata.

using Microsoft.Azure.Functions.Worker;
using Microsoft.DurableTask;
using Microsoft.Agents.AI.DurableTask;

[Function(nameof(ContentApprovalWorkflow))]
public static async Task<string> ContentApprovalWorkflow(
    [OrchestrationTrigger] TaskOrchestrationContext context)
{
    string topic = context.GetInput<string>();

    // Generate content using an agent
    DurableAIAgent contentAgent = context.GetAgent("ContentGenerationAgent");
    AgentResponse<GeneratedContent> contentResponse = 
        await contentAgent.RunAsync<GeneratedContent>($"Write an article about {topic}");
    GeneratedContent draftContent = contentResponse.Result;

    // Send for human review
    await context.CallActivityAsync(nameof(NotifyReviewer), draftContent);

    // Wait for approval with timeout
    HumanApprovalResponse approvalResponse;
    try
    {
        approvalResponse = await context.WaitForExternalEvent<HumanApprovalResponse>(
            eventName: "ApprovalDecision",
            timeout: TimeSpan.FromHours(24));
    }
    catch (OperationCanceledException)
    {
        // Timeout occurred - escalate for review
        return await context.CallActivityAsync<string>(nameof(EscalateForReview), draftContent);
    }

    if (approvalResponse.Approved)
    {
        return await context.CallActivityAsync<string>(nameof(PublishContent), draftContent);
    }

    return "Content rejected";
}

from durabletask.task import OrchestrationContext, when_any
from datetime import timedelta
from agent_framework_azurefunctions import AgentFunctionApp

app = AgentFunctionApp(agents=[content_agent])

@app.orchestration_trigger(context_name="context")
def content_approval_workflow(context: OrchestrationContext, topic: str):
    # Generate content using an agent
    content_agent = app.get_agent(context, "ContentGenerationAgent")
    draft_content = yield content_agent.run(
        messages=f"Write an article about {topic}"
    )

    # Send for human review
    yield context.call_activity("notify_reviewer", input=draft_content.text)

    # Wait for approval with timeout
    approval_task = context.wait_for_external_event("ApprovalDecision")
    timeout_task = context.create_timer(
        context.current_utc_datetime + timedelta(hours=24)
    )

    winner = yield when_any([approval_task, timeout_task])

    if winner == approval_task:
        timeout_task.cancel()
        approval_data = approval_task.result
        if approval_data.get("approved"):
            result = yield context.call_activity("publish_content", input=draft_content.text)
            return result
        return "Content rejected"

    # Timeout occurred - escalate for review
    result = yield context.call_activity("escalate_for_review", input=draft_content.text)
    return result

Deterministiska agentorkestreringar kan vänta på externa händelser och varaktigt bevara deras tillstånd medan de väntar på mänsklig feedback, överleva fel, omstarter och förlängda väntetider. När det mänskliga svaret kommer återupptas orkestreringen automatiskt med fullständigt konversationssammanhang och exekveringstillstånd intakt.

Tillhandahålla mänskliga indata

Om du vill skicka godkännande eller indata till en väntande orkestrering skapar du en extern händelse till orkestreringsinstansen med klient-SDK:t durable task eller slutpunkterna för Azure Functions Durable-tillägget. En granskare kan till exempel godkänna innehåll via ett webbformulär som anropar:

await client.RaiseEventAsync(instanceId, "ApprovalDecision", new HumanApprovalResponse 
{ 
    Approved = true,
    Feedback = "Looks great!"
});

approval_data = {
    "approved": True,
    "feedback": "Looks great!"
}
await client.raise_event(instance_id, "ApprovalDecision", approval_data)

Kostnadseffektivitet

Arbetsflöden med mänsklig interaktion med varaktiga agenter är extremt kostnadseffektiva när de värdshusas på Azure Functions Flex Consumption-plan. För ett arbetsflöde som väntar 24 timmar på godkännande betalar du bara för några sekunders körningstid (tiden för att generera innehåll, skicka meddelanden och bearbeta svaret)– inte de 24 timmarna som väntar. Under väntetiden förbrukas inga beräkningsresurser.

Observerbarhet i samband med Durable Task Scheduler

Durable Task Scheduler (DTS) är den rekommenderade hållbara backendlösningen för era hållbara agenter, som erbjuder bästa prestanda, hanterad infrastruktur och inbyggd observerbarhet via ett UI-dashboard. Azure Functions appar kan använda andra lagringsserverdelar (till exempel Azure Storage), men DTS är särskilt optimerat för hållbara arbetsbelastningar och ger överlägsna prestanda- och övervakningsfunktioner. Lokalt installerade arbetare använder också DTS för hållbar schemaläggning, tillstånd och instrumentpanelssynlighet.

Insikter om agentsessioner

  • Konversationshistorik: Visa fullständig chatthistorik för varje agentsession, inklusive alla meddelanden, verktygsanrop och konversationskontext när som helst
  • Tidsinställning för aktiviteter: Övervaka hur lång tid det tar för specifika uppgifter och agentinteraktioner att slutföras

Skärmbild av instrumentpanelen Durable Task Scheduler som visar agentchatthistorik med konversationstrådar och meddelanden.

Orkestreringsinsikter

  • Visualisering med flera agenter: Se körningsflödet när du anropar flera specialiserade agenter med visuell representation av parallella körningar och villkorsstyrd förgrening
  • Körningshistorik: Få åtkomst till detaljerade körningsloggar
  • Realtidsövervakning: Spåra aktiva orkestreringar, köade arbetsobjekt och agenttillstånd i din distribution
  • Prestandamått: Övervaka agentens svarstider, tokenanvändning och orkestreringstid

Skärmbild av kontrollpanelen Durable Task Scheduler som visar visualisering av orkestrering med interaktioner mellan agenter och arbetsflödets körning.

Felsökningsfunktioner

  • Visa strukturerade agentutdata och verktygsanropsresultat
  • Spårningsverktygsanrop och deras resultat
  • Övervaka extern händelsehantering för scenarier med människa i loopen

På instrumentpanelen kan du förstå exakt vad dina agenter gör, diagnostisera problem snabbt och optimera prestanda baserat på verkliga körningsdata.

Distribution och schemamigrering

Schema-v2-agenttillståndet ändrar både beständiga tillstånds- och sändningsidentiteter. Planera arbetssamarbete separat från tillståndskonvertering.

Nya sessioner använder entitetsnamnområdet dafx-v2- . Under en tvåfasig distribution lämnar ProcessLegacyEntities du inaktiverad medan v1-arbetare förblir aktiva. Stoppa alla v1-arbetare innan du aktiverar ProcessLegacyEntities för att bearbeta och uppgradera berättigade äldre entiteter på plats.

Fristående arbetare registrerar filter för arbetsobjekt. Funktionsdistributioner sida vid sida kräver också kompatibla Functions Worker-, DurableTask-arbetartillägg och AzureManaged Worker-tilläggspaket som stöder filtrering på värdsidan på varje deltagande värd, plus workItemFilteringEnabled i konfigurationen för scheduler-lagringsprovidern. Utan kompatibel filtrering använder du en offline-snabbkoppling i stället för samtidiga v1- och v2-värdar på en hubb. Följ uppgraderingsguiden för .NET för den fullständiga konfigurationen.

Välj en explicit strategi innan du skapar en värd:

  • two_phase: Använd Durable Task Scheduler med kompatibel filtrering av serverdelsarbetsobjekt. Nya versionsnamn isolerar dispatch medan berättigade äldre entiteter finns kvar på de gamla arbetarna. Stoppa gamla arbetare innan du aktiverar uppgradering av historiska namn och entitetsuppgraderingar på plats. Underhålla kompatibla filtrerade arbetare under samexistens; namnfilter är inte permanenta reservationer om flottan kopplas från.
  • isolated_v2: Använd en isolerad aktivitetshubb med matchande uppgraderade arbetare och klienter. Inställningen bekräftar isolering men avsöker inte andra arbetare. Använd nya arbetsflödesinstanser.

En ny hubb är inte ett villkorslöst krav för entitetsmigreringssökvägen med två faser. Mer information om konfiguration och krav finns i Python entitetsmigrering.

Varning

Entitetsmigrering reparerar inte arbetsflödets omspelningskompatibilitet. Påverkade äldre arbetsflödeshistorik, inklusive äldre v2-historik, stöds inte av den uppgraderade körningen. Om de måste slutföra, behålla dem på sina ursprungliga arbetare och hubb. Starta nya instanser efter uppgraderingen. förlita dig inte enbart på arbetsflödesversionsmarkören för att bevisa kompatibilitet. Se Python körningskompatibilitet.

Tillståndslivscykel och kapacitet

Välj principer för varje lager oberoende av varandra:

Skikt Vad den styr
Sessions-TTL Tar bort hela entiteten, inklusive konversationstillstånd och slutförandekvitton.
Kvarhållning av beständig historik Tar bort berättigat lagrat avskriftsinnehåll. skyddat tillstånd kan fortfarande överskrida kapaciteten.
Komprimering av modellindata Ändrar kontexten som skickas till modellen. Det behöver inte nödvändigtvis beskära hållbar historia.
Resultatkvarhållning Styr tillgängligheten för svarsnyttolast oberoende av det behållna slutföranderesultatet.
Livscykel för blobnyttolast Styr SDK-avlastade nyttolastblobar. borttagning eller orkestrering rensar inte upp dem.

I .NET schema-v2-kvittotillståndet tar inte den okonfigurerade äldre 14-dagars TTL-filen bort entiteten automatiskt. Konfigurera en global eller per agent-TTL explicit om du vill rensa inaktiv session. Att skicka timeToLive: null till AddAIAgent ärver den konfigurerade globala standardinställningen. Den åsidosätter inte en sjudagars global standard med "upphör aldrig att gälla". Ange DefaultTimeToLive = null för att inaktivera den globala TTL:en för agenter utan positiva åsidosättningar per agent.

.NET standardvärdet är DurableAgentHistoryRetentionMode.KeepAll; Auto möjliggör tryckbaserad transkriptionsbevarande. ResultRetentionPeriod standardvärdet är 60 sekunder och är separat från sessions-TTL. Python har distinkta alternativ för kvarhållning och budget, inklusive retention="keep_all" som standard. Anta inte samma alternativ eller standardvärden för värdar.

Python stöder valfri SDK-hanterad blobnyttolast avlastning i båda värdmodellerna. Konfigurera både producent- och konsumentlager, autentiseringsuppgifter och bloblivscykel. Avlastning tar inte bort kapacitetsbegränsningar för hela entiteter eller ersätter kvarhållning. behåll blobar medan referenstillstånd eller uppspelningshistorik behöver dem. Se .NET tillstånd och kvarhållning, Python kvarhållning och budgetar samt Python Functions Blob-avlastning.

Information om scheduler-infrastruktur, kapacitet och driftvägledning finns i Durable Task-integrering för Agent Framework.

Självstudie: Skapa och köra en varaktig agent med Azure Functions

Den här självstudien visar hur du skapar och kör en hållbar AI-agent med hjälp av Azure Functions värdmodell för Durable Extension. Du skapar en Azure Functions-app som är värd för en tillståndskänslig agent med inbyggda HTTP-slutpunkter och lär dig hur du övervakar den med instrumentpanelen Durable Task Scheduler. För lokalt installerade agenter, se exemplen.

Prerequisites

Kontrollera att du har följande förutsättningar innan du börjar:

Note

Microsoft Agent Framework stöds med alla versioner av .NET som stöds aktivt. I det här exemplet rekommenderar vi .NET 9 SDK eller en senare version.

Ange DURABLE_AGENTS_DEPLOYMENT_MODE=isolated_v2 först när du har bekräftat att självstudiehubben är isolerad och att alla arbetare och klienter använder den uppgraderade körningen.

Använd en ny aktivitetshubb för den här självstudien, separat från befintliga hållbara program. För ett befintligt program följer du distributions- och schemamigreringen i stället.

Ladda ned snabbstartsprojektet

Använd Azure Developer CLI för att initiera ett nytt projekt från snabbstartsmallen durable agents.

  1. Skapa en ny katalog för projektet och navigera till den:

    mkdir MyDurableAgent
cd MyDurableAgent

  1. Initiera projektet från mallen:

    azd init --template durable-agents-quickstart-dotnet

    När du uppmanas att ange ett miljönamn anger du ett namn som my-durable-agent.

Detta laddar ned snabbstartsprojektet med alla nödvändiga filer, inklusive Azure Functions-konfiguration, agentkod och infrastruktur som kodmallar.

  1. Skapa en ny katalog för projektet och navigera till den:

    mkdir MyDurableAgent
cd MyDurableAgent

  1. Initiera projektet från mallen:

    azd init --template durable-agents-quickstart-python

    När du uppmanas att ange ett miljönamn anger du ett namn som my-durable-agent.

  2. Skapa och aktivera en virtuell miljö:

    uv venv --python 3.13 .venv
source .venv/bin/activate

Note

Du kan också använda python -m venv .venv med en installerad Python 3.13-tolk. Om kommandot låser sig på Windows använder du uv venv kommandot ovan i stället. Kontrollera den aktiva tolken med python --version innan du installerar paket.

  1. Installera de paket som krävs:

    Uppdatera mallens requirements.txt till Functions-paketen i Komma igång, inklusive agent-framework-openai klientpaketet, innan du installerar. Lös motstridiga beroendestift i manifestet i stället för att tvinga installationen över dem.

    uv pip install -r requirements.txt

Detta laddar ned snabbstartsprojektet med alla nödvändiga filer, inklusive Azure Functions-konfiguration, agentkod och infrastruktur som kodmallar. Den förbereder också en virtuell miljö med nödvändiga beroenden.

Etablera Azure-resurser

Använd Azure Developer CLI för att skapa nödvändiga Azure-resurser för din varaktiga agent.

  1. Upprätta infrastrukturen

    azd provision

    Det här kommandot skapar:

    • En Azure OpenAI-tjänst med en gpt-4o-mini-distribution
    • En Azure Functions-app med Flex Consumption-hostingplan
    • Ett Azure Storage-konto för Azure Functions-körningen och beständig lagring
    • En Durable Task Scheduler-instans (konsumtionsplan) för hantering av agenttillstånd
    • Nödvändiga nätverks- och identitetskonfigurationer

  2. När du uppmanas till det väljer du din Azure-prenumeration och väljer en plats för resurserna.

Etableringsprocessen tar några minuter. När det är klart lagrar azd den skapade resursinformationen i din miljö.

Granska agentkoden

Nu ska vi undersöka koden som definierar din varaktiga agent.

Öppna Program.cs för att se agentkonfigurationen:

using Azure.AI.Projects;
using Azure.Identity;
using Microsoft.Agents.AI;
using Microsoft.Agents.AI.Hosting.AzureFunctions;
using Microsoft.Azure.Functions.Worker.Builder;
using Microsoft.Extensions.Hosting;

var endpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT") 
    ?? throw new InvalidOperationException("AZURE_OPENAI_ENDPOINT environment variable is not set");
var deploymentName = Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOYMENT") ?? "gpt-4o-mini";

// Create an AI agent following the standard Microsoft Agent Framework pattern
AIAgent agent = new AIProjectClient(new Uri(endpoint), new DefaultAzureCredential())
    .AsAIAgent(
        model: deploymentName,
        instructions: "You are a helpful assistant that can answer questions and provide information.",
        name: "MyDurableAgent");

using IHost app = FunctionsApplication
    .CreateBuilder(args)
    .ConfigureFunctionsWebApplication()
    .ConfigureDurableAgents(options => options.AddAIAgent(agent))
    .Build();
app.Run();

Den här koden:

  1. Hämtar din Azure OpenAI-konfiguration från miljövariabler.
  2. Skapar en Azure OpenAI-klient med azure-autentiseringsuppgifter.
  3. Skapar en AI-agent med instruktioner och ett namn.
  4. Konfigurerar Azure Functions-appen som värd för agenten med beständig trådhantering.

Öppna function_app.py för att se agentkonfigurationen:

import os
from agent_framework_azurefunctions import AgentFunctionApp
from agent_framework.openai import OpenAIChatCompletionClient
from azure.identity import DefaultAzureCredential

endpoint = os.getenv("AZURE_OPENAI_ENDPOINT")
if not endpoint:
    raise ValueError("AZURE_OPENAI_ENDPOINT is not set.")
deployment_name = os.getenv("AZURE_OPENAI_DEPLOYMENT", "gpt-4o-mini")
api_version = os.getenv("AZURE_OPENAI_API_VERSION")

# Create an AI agent following the standard Microsoft Agent Framework pattern
agent = OpenAIChatCompletionClient(
    azure_endpoint=endpoint,
    model=deployment_name,
    api_version=api_version,
    credential=DefaultAzureCredential()
).as_agent(
    instructions="You are a helpful assistant that can answer questions and provide information.",
    name="MyDurableAgent"
)

# Configure the function app to host the agent with durable thread management
app = AgentFunctionApp(agents=[agent])

Den här koden:

  • Hämtar din Azure OpenAI-konfiguration från miljövariabler.
  • Skapar en Azure OpenAI-klient med azure-autentiseringsuppgifter.
  • Skapar en AI-agent med instruktioner och ett namn.
  • Konfigurerar Azure Functions-appen som värd för agenten med beständig trådhantering.

Agenten är nu redo att finnas i Azure Functions. Det varaktiga aktivitetstillägget skapar automatiskt HTTP-slutpunkter för att interagera med din agent och hanterar konversationstillstånd för flera begäranden.

Konfigurera lokala inställningar

Skapa en local.settings.json fil för lokal utveckling baserat på exempelfilen som ingår i projektet.

  1. Kopiera exempelinställningsfilen:

    cp local.settings.sample.json local.settings.json

  1. Hämta din Azure OpenAI-slutpunkt från de etablerade resurserna:

    azd env get-value AZURE_OPENAI_ENDPOINT

  2. Öppna local.settings.json och ersätt <your-resource-name> i AZURE_OPENAI_ENDPOINT värdet med slutpunkten från föregående kommando.

Din local.settings.json ska se ut så här:

{
  "IsEncrypted": false,
  "Values": {
    // ... other settings ...
    "AzureWebJobsStorage": "UseDevelopmentStorage=true",
    "AZURE_OPENAI_ENDPOINT": "https://your-openai-resource.openai.azure.com",
    "AZURE_OPENAI_DEPLOYMENT": "gpt-4o-mini",
    "DURABLE_TASK_SCHEDULER_CONNECTION_STRING": "Endpoint=http://localhost:8080;TaskHub=default;Authentication=None",
    "TASKHUB_NAME": "default"
  }
}

Note

Filen local.settings.json används endast för lokal utveckling och distribueras inte till Azure. För produktionsdistributioner konfigureras de här inställningarna automatiskt i Azure Functions-appen av infrastrukturmallarna.

För Python lägger du bara till "DURABLE_AGENTS_DEPLOYMENT_MODE": "isolated_v2" i när du har bekräftat att Values självstudiehubben är isolerad. Konfigurera motsvarande programinställning när du distribuerar. lokala inställningar laddas inte upp automatiskt.

För scheduler-backad värd använder du samma aktivitetshubb i host.json (via %TASKHUB_NAME%), TASKHUB_NAME, DURABLE_TASK_SCHEDULER_CONNECTION_STRING, emulatorn och instrumentpanelen. I den här självstudien används default, som emulatorn skapar automatiskt. Om hubben redan innehåller gamla historier eller används av andra arbetare väljer du ett unikt, oanvänt hubbnamn, anger emulatorns DTS_TASK_HUB_NAMES till det namnet och uppdaterar programinställningarna och instrumentpanelens val konsekvent. Att bara definiera en schemaläggare reťazec pripojenia väljer inte scheduler-lagringsprovidern.

I host.jsonkonfigurerar du scheduler-providern under extensions.durableTaskoch bevarar mallens andra värdinställningar:

{
  "extensions": {
    "durableTask": {
      "hubName": "%TASKHUB_NAME%",
      "storageProvider": {
        "type": "AzureManaged",
        "connectionStringName": "DURABLE_TASK_SCHEDULER_CONNECTION_STRING"
      }
    }
  }
}

Använd scheduler-providerns beroenden för ditt värdspråk. Den här konfigurationen väljer serverdelen för en ny isolerad självstudiedistribution. Den aktiverar inte den filtrering som krävs för en sida-vid-sida-uppgradering.

Starta lokala beroenden för utveckling

Om du vill köra varaktiga agenter lokalt måste du starta två tjänster:

  • Azurite: Emulerar Azure Storage-tjänster (används av Azure Functions för att hantera utlösare och internt tillstånd).
  • DTS-emulator (Durable Task Scheduler): Hanterar varaktigt tillstånd (konversationshistorik, orkestreringstillstånd) och schemaläggning för dina agenter

De här stegen förutsätter att Functions-värden använder lagringsprovidern Durable Task Scheduler. Versionens Python Functions-exempel är som standard Azure Storage. Om du börjar med dessa exempel väljer och konfigurerar du scheduler-providern innan du använder DTS-instrumentpanelen. Annars har Azurite det varaktiga tillståndet och scheduler-instrumentpanelen förblir tom. Se Installation av Durable Task Scheduler.

Starta Azurite

Azurite emulerar Azure Storage-tjänster lokalt. Azure Functions använder det för att hantera internt tillstånd. Du måste köra detta i ett nytt terminalfönster och hålla det igång medan du utvecklar och testar din varaktiga agent.

  1. Öppna ett nytt terminalfönster och hämta Azurite Docker-avbildningen:

    docker pull mcr.microsoft.com/azure-storage/azurite

  2. Starta Azurite i ett terminalfönster:

    docker run -p 10000:10000 -p 10001:10001 -p 10002:10002 mcr.microsoft.com/azure-storage/azurite

    Azurite startar och lyssnar på standardportarna för blobtjänster (10000), Kö (10001) och Tabell (10002).

Håll det här terminalfönstret öppet medan du utvecklar och testar din varaktiga agent.

Tip

Mer information om Azurite, inklusive alternativa installationsmetoder, finns i Använda Azurite-emulatorn för lokal Azure Storage-utveckling.

Starta emulatorn Durable Task Scheduler

DTS-emulatorn tillhandahåller den hållbara serverdelen för hantering av agenttillstånd och orkestreringar. Den lagrar konversationshistorik och säkerställer att agentens tillstånd kvarstår vid omstart. Det utlöser också varaktiga orkestreringar och agenter. Du måste köra detta i ett separat nytt terminalfönster och hålla det igång medan du utvecklar och testar din varaktiga agent.

  1. Öppna ett nytt terminalfönster och hämta Docker-avbildningen för DTS-emulatorn:

    docker pull mcr.microsoft.com/dts/dts-emulator:latest

  2. Kör DTS-emulatorn:

    docker run -p 8080:8080 -p 8082:8082 mcr.microsoft.com/dts/dts-emulator:latest

    Det här kommandot skapar default aktivitetshubben och startar emulatorn och matchar inställningarna för den här självstudien. Kommandot exponerar:

    • Port 8080: gRPC-slutpunkten för Durable Task Scheduler (används av din Functions-app)
    • Port 8082: Den administrativa kontrollpanelen

  3. Instrumentpanelen kommer att vara tillgänglig på http://localhost:8082.

Håll det här terminalfönstret öppet medan du utvecklar och testar din varaktiga agent.

Tip

Mer information om DTS-emulatorn, inklusive hur du konfigurerar flera aktivitetshubbar och får åtkomst till instrumentpanelen, finns i Utveckla med Durable Task Scheduler.

Kör funktionsappen

Nu är du redo att köra din Azure Functions-app med den hållbara agenten.

  1. I ett nytt terminalfönster (där både Azurite och DTS-emulatorn körs i separata fönster) navigerar du till projektkatalogen.

  2. Starta Azure Functions-körningen:

    func start

  3. Du bör se utdata som anger att funktionsappen körs, inklusive HTTP-slutpunkterna för din agent:

    Functions:
     http-MyDurableAgent: [POST] http://localhost:7071/api/agents/MyDurableAgent/run
     dafx-v2-MyDurableAgent: entityTrigger

Detta illustrerar .NET schema-v2-registrering; Python utlösarnamn beror på distributionsstrategin. Dessa slutpunkter hanterar konversationstillstånd automatiskt, så du behöver inte skapa sessionsobjekt själv.

Testa agenten lokalt

Nu kan du interagera med din varaktiga agent med hjälp av HTTP-begäranden. Agenten upprätthåller konversationstillstånd för flera begäranden, vilket möjliggör konversationer med flera turer.

Starta en ny konversation

Skapa en ny session och skicka ditt första meddelande:

curl -i -X POST http://localhost:7071/api/agents/MyDurableAgent/run \
  -H "Content-Type: text/plain" \
  -d "What are three popular programming languages?"

Exempelsvar (x-ms-session-idrubriken innehåller sessions-ID: i det här exemplet visas ett .NET schema-v2-ID):

HTTP/1.1 200 OK
Content-Type: text/plain
x-ms-session-id: @dafx-v2-mydurableagent@263fa373-fa01-4705-abf2-5a114c2bb87d
Content-Length: 189

Three popular programming languages are Python, JavaScript, and Java. Python is known for its simplicity and readability, JavaScript powers web interactivity, and Java is widely used in enterprise applications.

Spara det exakta sessions-ID: x-ms-session-id t från rubriken för nästa begäran. Skapa eller skriv inte om den. Python returnerar även den här rubriken, men dess ID-format kan skilja sig åt.

Fortsätt konversationen

Skicka ett uppföljningsmeddelande till samma session genom att inkludera det returnerade ID:t i den kanoniska frågeparametern sessionId :

Ersätt exempel-ID:t med det faktiska värdet från föregående svarsrubrik x-ms-session-id . URL-koda värdet om det behövs.

curl -X POST "http://localhost:7071/api/agents/MyDurableAgent/run?sessionId=@dafx-v2-mydurableagent@263fa373-fa01-4705-abf2-5a114c2bb87d" \
  -H "Content-Type: text/plain" \
  -d "Which one is best for beginners?"

Exempelsvar:

Python is often considered the best choice for beginners among those three. Its clean syntax reads almost like English, making it easier to learn programming concepts without getting overwhelmed by complex syntax. It's also versatile and widely used in education.

Observera att agenten kommer ihåg kontexten från föregående meddelande (de tre programmeringsspråken) utan att du behöver ange dem igen. Eftersom konversationstillståndet lagras korrekt av Durable Task Scheduler bevaras den här historiken även om du startar om funktionsappen eller om konversationen återupptas av en annan instans.

Övervaka med kontrollpanelen för Durable Task Scheduler

Durable Task Scheduler innehåller en inbyggd instrumentpanel för övervakning och felsökning av dina varaktiga agenter. Instrumentpanelen ger djup insyn i agentåtgärder, konversationshistorik och exekveringsflöde.

Få åtkomst till instrumentpanelen

  1. Öppna instrumentpanelen för din lokala DTS-emulator i http://localhost:8082 webbläsaren.

  2. Välj standard, eller samma unika hubbnamn som du konfigurerade i både programmet och emulatorn, för att visa dess information.

  3. Välj kugghjulsikonen i det övre högra hörnet för att öppna inställningarna och se till att alternativet Aktivera agentsidor under Förhandsversionsfunktioner är markerat.

Utforska agentkonversationer

  1. Gå till fliken Agenter på instrumentpanelen.

  2. Välj din durable agent-tråd (t.ex. mydurableagent - 263fa373-fa01-4705-abf2-5a114c2bb87d) i listan.

    Du ser en detaljerad vy över agenttråden, inklusive den fullständiga konversationshistoriken med alla meddelanden och svar.

    Skärmbild av instrumentpanelen Durable Task Scheduler som visar en agenttråds konversationshistorik.

Instrumentpanelen innehåller en tidslinjevy som hjälper dig att förstå konversationsflödet. Viktig information är:

  • Tidsstämplar och varaktighet för varje interaktion
  • Meddelande- och svarsinnehåll
  • Antal token som används

Tip

DTS-instrumentpanelen innehåller realtidsuppdateringar så att du kan se agentens beteende när du interagerar med den via HTTP-slutpunkterna.

Distribuera till Azure

Nu när du har testat din varaktiga agent lokalt distribuerar du den till Azure.

  1. Distribuera programmet:

    azd deploy

    Det här kommandot paketerar ditt program och distribuerar det till Azure Functions-appen som skapades under etableringen.

  2. Vänta tills distributionen har slutförts. Utdata bekräftar när agenten körs i Azure.

Testa den utplacerade agenten

Testa din agent som körs i Azure efter distributionen.

Hämta funktionsnyckeln

För de genererade slutpunkternas standardauktorisering på funktionsnivå inkluderar du en Functions-nyckel i begäranden om att Azure. En Functions-nyckel är inte programanvändarauktorisering. se produktionssäkerhet och felsökning.

API_KEY=`az functionapp function keys list --name $(azd env get-value AZURE_FUNCTION_NAME) --resource-group $(azd env get-value AZURE_RESOURCE_GROUP) --function-name http-MyDurableAgent --query default -o tsv`

Starta en ny konversation i Azure

Skapa en ny session och skicka ditt första meddelande till den distribuerade agenten:

curl -i -X POST "https://$(azd env get-value AZURE_FUNCTION_NAME).azurewebsites.net/api/agents/MyDurableAgent/run?code=$API_KEY" \
  -H "Content-Type: text/plain" \
  -d "What are three popular programming languages?"

Spara sessions-ID:t som returneras i svarshuvudet x-ms-session-id .

Fortsätt konversationen i Azure

Skicka ett uppföljningsmeddelande i samma session. Använd det exakta ID som returnerades av föregående svar:

SESSION_ID="<session-id>"
curl -X POST "https://$(azd env get-value AZURE_FUNCTION_NAME).azurewebsites.net/api/agents/MyDurableAgent/run?code=$API_KEY" \
  --url-query "sessionId=$SESSION_ID" \
  -H "Content-Type: text/plain" \
  -d "Which is easiest to learn?"

Agenten upprätthåller konversationskontexten i Azure precis som den gjorde lokalt, vilket visar agenttillståndets hållbarhet.

Övervaka den distribuerade agenten

Du kan övervaka din driftsatta agent via instrumentpanelen Durable Task Scheduler i Azure.

  1. Hämta namnet på din Durable Task Scheduler-instans:

    azd env get-value DTS_NAME

  2. Öppna Azure-portalen och sök efter namnet på Durable Task Scheduler från föregående steg.

  3. På översiktsbladet för resursen Durable Task Scheduler väljer du den aktivitetshubb som konfigurerats för det distribuerade programmet.

  4. Välj Öppna instrumentpanel överst på sidan för aktivitetshubben för att öppna instrumentpanelen för övervakning.

  5. Visa agentens konversationer precis som du gjorde med den lokala emulatorn.

Instrumentpanelen i Azure innehåller samma felsöknings- och övervakningsfunktioner som den lokala emulatorn, så att du kan granska konversationshistorik, spåra verktygsanrop och analysera prestanda i produktionsmiljön.

Självstudie: Dirigera varaktiga agenter med Azure Functions

Den här självstudien visar hur du orkestrera flera hållbara AI-agenter med hjälp av Azure Functions-värdmodellen och mönstret fan-out/fan-in. Du utökar den varaktiga agenten från föregående självstudiekurs för att skapa ett system med flera agenter som bearbetar en användares fråga och sedan översätter svaret till flera språk samtidigt. Exempel på orkestrering med egen värd finns i exemplen.

Förstå orkestreringsmönstret

Orkestreringen som du skapar följer det här flödet:

  1. Användarindata – en fråga eller ett meddelande från användaren
  2. Huvudagent – Den MyDurableAgent från den första självstudiekursen bearbetar frågan
  3. "Fan-out" – huvudagentens svar skickas samtidigt till båda översättningsagenterna
  4. Översättningsagenter – Två specialiserade agenter översätter svaret (franska och spanska)
  5. Fan-in – Resultaten aggregeras till ett enda JSON-svar med det ursprungliga svaret och översättningarna

Det här mönstret möjliggör samtidig bearbetning, vilket minskar den totala svarstiden jämfört med sekventiell översättning.

Registrera agenter vid start

Om du vill använda agenter korrekt i varaktiga orkestreringar registrerar du dem vid programstart. De kan användas mellan orkestreringskörningar.

Uppdatera din Program.cs för att registrera översättningsagenterna tillsammans med den befintliga MyDurableAgent:

using System;
using Azure.AI.Projects;
using Azure.Identity;
using Microsoft.Agents.AI;
using Microsoft.Agents.AI.Hosting.AzureFunctions;
using Microsoft.Azure.Functions.Worker.Builder;
using Microsoft.Extensions.Hosting;

// Get the Azure OpenAI configuration
string endpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT")
    ?? throw new InvalidOperationException("AZURE_OPENAI_ENDPOINT is not set.");
string deploymentName = Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOYMENT")
    ?? "gpt-4o-mini";

// Create the Microsoft Foundry client
AIProjectClient client = new(new Uri(endpoint), new DefaultAzureCredential());

// Create the main agent from the first tutorial
AIAgent mainAgent = client.AsAIAgent(
    model: deploymentName,
    instructions: "You are a helpful assistant that can answer questions and provide information.",
    name: "MyDurableAgent");

// Create translation agents
AIAgent frenchAgent = client.AsAIAgent(
    model: deploymentName,
    instructions: "You are a translator. Translate the following text to French. Return only the translation, no explanations.",
    name: "FrenchTranslator");

AIAgent spanishAgent = client.AsAIAgent(
    model: deploymentName,
    instructions: "You are a translator. Translate the following text to Spanish. Return only the translation, no explanations.",
    name: "SpanishTranslator");

// Build and configure the Functions host
using IHost app = FunctionsApplication
    .CreateBuilder(args)
    .ConfigureFunctionsWebApplication()
    .ConfigureDurableAgents(options =>
    {
        // Register all agents for use in orchestrations and HTTP endpoints
        options.AddAIAgent(mainAgent);
        options.AddAIAgent(frenchAgent);
        options.AddAIAgent(spanishAgent);
    })
    .Build();

app.Run();

Uppdatera din function_app.py för att registrera översättningsagenterna tillsammans med den befintliga MyDurableAgent:

import os
from azure.identity import DefaultAzureCredential
from agent_framework_azurefunctions import AgentFunctionApp
from agent_framework.openai import OpenAIChatCompletionClient

# Get the Azure OpenAI configuration
endpoint = os.getenv("AZURE_OPENAI_ENDPOINT")
if not endpoint:
    raise ValueError("AZURE_OPENAI_ENDPOINT is not set.")
deployment_name = os.getenv("AZURE_OPENAI_DEPLOYMENT", "gpt-4o-mini")
api_version = os.getenv("AZURE_OPENAI_API_VERSION")

# Create the Azure OpenAI client
chat_client = OpenAIChatCompletionClient(
    azure_endpoint=endpoint,
    model=deployment_name,
    api_version=api_version,
    credential=DefaultAzureCredential()
)

# Create the main agent from the first tutorial
main_agent = chat_client.as_agent(
    instructions="You are a helpful assistant that can answer questions and provide information.",
    name="MyDurableAgent"
)

# Create translation agents
french_agent = chat_client.as_agent(
    instructions="You are a translator. Translate the following text to French. Return only the translation, no explanations.",
    name="FrenchTranslator"
)

spanish_agent = chat_client.as_agent(
    instructions="You are a translator. Translate the following text to Spanish. Return only the translation, no explanations.",
    name="SpanishTranslator"
)

# Create the function app and register all agents
app = AgentFunctionApp(agents=[main_agent, french_agent, spanish_agent])

Skapa en orkestreringsfunktion

En orkestreringsfunktion samordnar arbetsflödet mellan flera agenter. Den hämtar registrerade agenter från den varaktiga kontexten och samordnar deras körning, anropar först huvudagenten och ger sedan ut till översättningsagenter samtidigt.

Skapa en ny fil med namnet AgentOrchestration.cs i projektkatalogen:

using System.Collections.Generic;
using System.Threading.Tasks;
using Microsoft.Agents.AI;
using Microsoft.Agents.AI.DurableTask;
using Microsoft.Azure.Functions.Worker;
using Microsoft.DurableTask;

namespace MyDurableAgent;

public static class AgentOrchestration
{
    // Define a strongly-typed response structure for agent outputs
    public sealed record TextResponse(string Text);

    [Function("agent_orchestration_workflow")]
    public static async Task<Dictionary<string, string>> AgentOrchestrationWorkflow(
        [OrchestrationTrigger] TaskOrchestrationContext context)
    {
        var input = context.GetInput<string>() ?? throw new ArgumentNullException(nameof(context), "Input cannot be null");

        // Step 1: Get the main agent's response
        DurableAIAgent mainAgent = context.GetAgent("MyDurableAgent");
        AgentResponse<TextResponse> mainResponse = await mainAgent.RunAsync<TextResponse>(input);
        string agentResponse = mainResponse.Result.Text;

        // Step 2: Fan out - get the translation agents and run them concurrently
        DurableAIAgent frenchAgent = context.GetAgent("FrenchTranslator");
        DurableAIAgent spanishAgent = context.GetAgent("SpanishTranslator");

        Task<AgentResponse<TextResponse>> frenchTask = frenchAgent.RunAsync<TextResponse>(agentResponse);
        Task<AgentResponse<TextResponse>> spanishTask = spanishAgent.RunAsync<TextResponse>(agentResponse);

        // Step 3: Wait for both translation tasks to complete (fan-in)
        await Task.WhenAll(frenchTask, spanishTask);

        // Get the translation results
        TextResponse frenchResponse = (await frenchTask).Result;
        TextResponse spanishResponse = (await spanishTask).Result;

        // Step 4: Combine results into a dictionary
        var result = new Dictionary<string, string>
        {
            ["original"] = agentResponse,
            ["french"] = frenchResponse.Text,
            ["spanish"] = spanishResponse.Text
        };

        return result;
    }
}

Lägg till orkestreringsfunktionen i function_app.py filen:

from durabletask.task import OrchestrationContext, when_all

@app.orchestration_trigger(context_name="context")
def agent_orchestration_workflow(context: OrchestrationContext, input_text: str):
    """
    Orchestration function that coordinates multiple agents.
    Returns a dictionary with the original response and translations.
    """
    # Step 1: Get the main agent's response
    main_agent = app.get_agent(context, "MyDurableAgent")
    main_response = yield main_agent.run(input_text)
    agent_response = main_response.text

    # Step 2: Fan out - get the translation agents and run them concurrently
    french_agent = app.get_agent(context, "FrenchTranslator")
    spanish_agent = app.get_agent(context, "SpanishTranslator")

    parallel_tasks = [
        french_agent.run(agent_response),
        spanish_agent.run(agent_response)
    ]

    # Step 3: Wait for both translation tasks to complete (fan-in)
    translations = yield when_all(parallel_tasks)

    # Step 4: Combine results into a dictionary
    result = {
        "original": agent_response,
        "french": translations[0].text,
        "spanish": translations[1].text
    }

    return result

Note

Den här guiden beskriver C# och Python durable extension hosting. För Go-värd, se A2A-värd och Agent Framework Go-lagringsplatsen.

Testa orkestreringen

Se till att dina lokala utvecklingsberoenden från den första självstudien fortfarande körs:

  • Azurite i ett terminalfönster
  • Durable Task Scheduler-emulator i ett annat terminalfönster

Med dina lokala utvecklingsberoenden igång:

  1. Starta din Azure Functions-app i ett nytt terminalfönster:

    func start

  2. Durable Functions-tillägget skapar automatiskt inbyggda HTTP-slutpunkter för hantering av orkestreringar. Starta orkestreringen med hjälp av det inbyggda API:et:

    curl -X POST http://localhost:7071/runtime/webhooks/durabletask/orchestrators/agent_orchestration_workflow \
  -H "Content-Type: application/json" \
  -d '"\"What are three popular programming languages?\""'

  1. Svaret innehåller URL:er för att hantera orkestreringsinstansen:

    {
  "id": "abc123def456",
  "statusQueryGetUri": "http://localhost:7071/runtime/webhooks/durabletask/instances/abc123def456",
  "sendEventPostUri": "http://localhost:7071/runtime/webhooks/durabletask/instances/abc123def456/raiseEvent/{eventName}",
  "terminatePostUri": "http://localhost:7071/runtime/webhooks/durabletask/instances/abc123def456/terminate",
  "purgeHistoryDeleteUri": "http://localhost:7071/runtime/webhooks/durabletask/instances/abc123def456"
}

  2. Använd statusQueryGetUri för att fråga om orkestreringens status (ersätt abc123def456 med ditt faktiska instans-ID):

    curl http://localhost:7071/runtime/webhooks/durabletask/instances/abc123def456

  1. Avsök statusslutpunkten tills runtimeStatus den är Completed. När processen är klar kommer du att se ett samordningsresultat med huvudagentens svar och dess översättningar:

    {
  "name": "agent_orchestration_workflow",
  "instanceId": "abc123def456",
  "runtimeStatus": "Completed",
  "output": {
    "original": "Three popular programming languages are Python, JavaScript, and Java. Python is known for its simplicity...",
    "french": "Trois langages de programmation populaires sont Python, JavaScript et Java. Python est connu pour sa simplicité...",
    "spanish": "Tres lenguajes de programación populares son Python, JavaScript y Java. Python es conocido por su simplicidad..."
  }
}

Övervaka orkestreringen på instrumentpanelen

Dashboarden Durable Task Scheduler ger en översikt över din orkestrering:

  1. Öppna http://localhost:8082 i din webbläsare.

  2. Välj den aktivitetshubb som konfigurerats för ditt program.

  3. Välj fliken Orkestrering.

  4. Hitta orkestreringsinstansen i listan.

  5. Välj den instans som ska visas:

    • Tidslinjen för orkestrering
    • Huvudagentutförande som följs av samtidiga översättningsagenter
    • Varje agentkörning (MyDurableAgent; sedan franska och spanska översättarna)
    • Fan-out och fan-in mönster visualiserade
    • Tidsinställning och varaktighet för varje steg

Distribuera orkestreringen till Azure

Distribuera det uppdaterade programmet med Hjälp av Azure Developer CLI:

azd deploy

Detta distribuerar din uppdaterade kod med den nya orkestreringsfunktionen och ytterligare agenter till appen Azure Functions som skapades i den första handledningen.

Testa den distribuerade orkestreringen

Efter distributionen testar du orkestreringen som körs i Azure.

  1. Hämta systemnyckeln för det hållbara tillägget:

    SYSTEM_KEY=$(az functionapp keys list --name $(azd env get-value AZURE_FUNCTION_NAME) --resource-group $(azd env get-value AZURE_RESOURCE_GROUP) --query "systemKeys.durabletask_extension" -o tsv)

  1. Starta orkestreringen med hjälp av det inbyggda API:et:

    curl -X POST "https://$(azd env get-value AZURE_FUNCTION_NAME).azurewebsites.net/runtime/webhooks/durabletask/orchestrators/agent_orchestration_workflow?code=$SYSTEM_KEY" \
  -H "Content-Type: application/json" \
  -d '"\"What are three popular programming languages?\""'
  1. Använd statusQueryGetUri från svaret för att avsöka efter slutförande och visa resultaten med översättningar.

Produktionssäkerhet och felsökning

Hantera dessa åtkomstgränser separat:

  • Programanvändare: Autentisera anropare och auktorisera åtkomst till varje session, arbetsflöde och svar om mänskligt godkännande. Sessions-, korrelations- och begärande-ID:er är identifierare, inte autentiseringsuppgifter.
  • Funktionsslutpunkter: Nycklar på funktionsnivå skyddar genererade HTTP-slutpunkter men etablerar inte programanvändarens identitet eller sessionsägarskap. Skydda och rotera nycklar; exponera dem inte i webbläsarlevererad programkod.
  • Modellåtkomst: Ge arbetsidentiteten de nödvändiga modellbehörigheterna. Modellautentiseringsuppgifter ger inte åtkomst till schemaläggaren eller till en annan användares session.
  • Scheduler-åtkomst: Konfigurera arbets-, klient- och instrumentpanelsbehörigheter för deras avsedda roller. Vägledning om infrastruktur finns i Durable Task-integrering.
Symtom Check
Python paketinstallation eller functions-start misslyckas Använd Python 3.13 eller senare för Functions, installera Functions-paketen i Komma igång och välj uttryckligen en distributionsstrategi. Det fristående Python minimum är annorlunda.
Begäranden lyckas men DTS-instrumentpanelen är tom Bekräfta att Functions-lagringsprovidern är AzureManaged, inte AzureStorage, och att schemaläggarens slutpunkt och uppgiftshubb matchar instrumentpanelen.
En session verkar förlora kontext Återanvänd det exakta returnerade x-ms-session-id värdet med sessionId; sök efter en annan hubb, distributionsnamnområde eller konfigurerad sessionsrensning.
Gamla arbetsflöden misslyckas efter uppgradering Kontrollera omspelningskompatibiliteten innan du återupptar historiska körningar. Entitetsmigrering reparerar inte inkompatibla arbetsflödeshistoriker.
En ström avslutas men varaktigt slutförande saknas Behandla strömutdata som preliminära och kontrollera det auktoritativa resultatet eller det kvarhållna resultatet. En markör för dataströmskomplettering är inte en beständiga bekräftelse.
En slutförd åtgärd returnerar 410 Granska det kvarhållna resultatet och resultattillgängligheten. Anta inte fel, behåll avsökningen som om den var väntande eller skicka automatiskt en ny åtgärd.
Skrivningar i entitetstillstånd överskrider kapaciteten Granska tillstånd för hela entiteter, skyddade poster, kvarhållningsprincip och nyttolastreferenser. Enbart komprimering av modellindata garanterar inte att lagrat tillstånd passar.

Nästa steg

OpenAI-kompatibla API-slutpunkter

Ytterligare resurser:

  • Uppdaterades senast