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
)

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
)

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"
    )

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