Azure Functions Integration

from agent_framework.azure import AgentFunctionApp, AzureOpenAIChatClient
from azure.identity import AzureCliCredential
from dotenv import load_dotenv

load_dotenv()

# Create agent with specific instructions
def _create_agent():
    return AzureOpenAIChatClient(credential=AzureCliCredential()).as_agent(
        name="Joker",
        instructions="You are good at telling jokes.",
    )

# Register agent with Functions app
app = AgentFunctionApp(
    agents=[_create_agent()],
    enable_health_check=True,
    max_poll_retries=50
)

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

string endpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT")
    ?? throw new InvalidOperationException("AZURE_OPENAI_ENDPOINT is not set.");
string deploymentName = Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOYMENT_NAME")
    ?? throw new InvalidOperationException("AZURE_OPENAI_DEPLOYMENT_NAME is not set.");

var client = new AzureOpenAIClient(new Uri(endpoint), new DefaultAzureCredential());
AIAgent agent = client.GetChatClient(deploymentName)
    .AsAIAgent("You are good at telling jokes.", "Joker");

using IHost app = FunctionsApplication
    .CreateBuilder(args)
    .ConfigureFunctionsWebApplication()
    .ConfigureDurableAgents(options => 
        options.AddAIAgent(agent, timeToLive: TimeSpan.FromHours(1)))
    .Build();

app.Run();

from agent_framework import tool
from agent_framework.azure import AgentFunctionApp, AzureOpenAIChatClient
from azure.identity import AzureCliCredential

# Define tools
@tool(approval_mode="never_require")
def get_weather(location: str) -> dict:
    """Get current weather for a location."""
    return {
        "location": location,
        "temperature": 72,
        "conditions": "Sunny"
    }

@tool(approval_mode="never_require")
def calculate_tip(bill_amount: float, tip_percentage: float = 15.0) -> dict:
    """Calculate tip amount and total bill."""
    tip = bill_amount * (tip_percentage / 100)
    return {
        "bill_amount": bill_amount,
        "tip_amount": round(tip, 2),
        "total": round(bill_amount + tip, 2)
    }

# Create specialized agents
client = AzureOpenAIChatClient(credential=AzureCliCredential())

weather_agent = client.as_agent(
    name="WeatherAgent",
    instructions="You are a helpful weather assistant.",
    tools=[get_weather]
)

math_agent = client.as_agent(
    name="MathAgent",
    instructions="You are a helpful math assistant.",
    tools=[calculate_tip]
)

# Register all agents
app = AgentFunctionApp(
    agents=[weather_agent, math_agent],
    enable_health_check=True
)

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

// Create specialized agents
AIAgent weatherAgent = client.GetChatClient(deploymentName).AsAIAgent(
    "You are a helpful weather assistant.",
    "WeatherAgent",
    tools: [GetWeatherTool()]);

AIAgent mathAgent = client.GetChatClient(deploymentName).AsAIAgent(
    "You are a helpful math assistant.",
    "MathAgent",
    tools: [CalculateTipTool()]);

// Register all agents
using IHost app = FunctionsApplication
    .CreateBuilder(args)
    .ConfigureFunctionsWebApplication()
    .ConfigureDurableAgents(options =>
    {
        options.AddAIAgent(weatherAgent);
        options.AddAIAgent(mathAgent);
    })
    .Build();

app.Run();

import azure.functions as func
from azure.durable_functions import DurableOrchestrationContext, DurableOrchestrationClient
from agent_framework.azure import AgentFunctionApp, AzureOpenAIChatClient
from azure.identity import AzureCliCredential

# Create agent
WRITER_AGENT_NAME = "WriterAgent"

def _create_writer_agent():
    return AzureOpenAIChatClient(credential=AzureCliCredential()).as_agent(
        name=WRITER_AGENT_NAME,
        instructions="""You refine short pieces of text. When given an initial 
        sentence you enhance it; when given an improved sentence you polish it further."""
    )

app = AgentFunctionApp(agents=[_create_writer_agent()], enable_health_check=True)

# Define orchestration
@app.orchestration_trigger(context_name="context")
def writer_orchestration(context: DurableOrchestrationContext):
    """Sequential agent calls with shared session."""
    writer = app.get_agent(context, WRITER_AGENT_NAME)
    session = writer.create_session()
    
    # First pass: initial content
    initial = yield writer.run(
        messages="Write a concise inspirational sentence about learning.",
        session=session
    )
    
    # Second pass: refinement
    improved_prompt = f"Improve this further while keeping it under 25 words: {initial.text}"
    refined = yield writer.run(
        messages=improved_prompt,
        session=session
    )
    
    return refined.text

# HTTP trigger to start orchestration
@app.route(route="writer/run", methods=["POST"])
@app.durable_client_input(client_name="client")
async def start_writer_orchestration(
    req: func.HttpRequest,
    client: DurableOrchestrationClient
) -> func.HttpResponse:
    """Start the orchestration."""
    instance_id = await client.start_new(
        orchestration_function_name="writer_orchestration"
    )
    
    return func.HttpResponse(
        body=f'{{"instanceId": "{instance_id}"}}',
        status_code=202,
        mimetype="application/json"
    )

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

public class WriterOrchestration
{
    [Function(nameof(RunWriterOrchestration))]
    public static async Task<string> RunWriterOrchestration(
        [OrchestrationTrigger] TaskOrchestrationContext context)
    {
        var logger = context.CreateReplaySafeLogger<WriterOrchestration>();
        var agent = context.GetAgent("WriterAgent");
        var session = agent.CreateSession();
        
        // First pass: initial content
        var initial = await agent.RunAsync(
            "Write a concise inspirational sentence about learning.",
            session: session);
        
        logger.LogInformation($"Initial: {initial.Text}");
        
        // Second pass: refinement
        var improved = $"Improve this further while keeping it under 25 words: {initial.Text}";
        var refined = await agent.RunAsync(improved, session: session);
        
        logger.LogInformation($"Refined: {refined.Text}");
        
        return refined.Text;
    }
    
    [Function(nameof(StartWriterOrchestration))]
    public static async Task<HttpResponseData> StartWriterOrchestration(
        [HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "writer/run")] 
        HttpRequestData req,
        [DurableClient] DurableTaskClient client)
    {
        string instanceId = await client.ScheduleNewOrchestrationInstanceAsync(
            nameof(RunWriterOrchestration));
        
        return await client.CreateCheckStatusResponseAsync(req, instanceId);
    }
}

app = AgentFunctionApp(
    agents=[agent],
    session_ttl=timedelta(hours=2)
)

options.AddAIAgent(
    agent,
    timeToLive: TimeSpan.FromHours(2));