[project]
dependencies = [
    "agent-framework-ag-ui>=1.0.0b251117",
    "python-dotenv",
]

from __future__ import annotations
from textwrap import dedent
from typing import Annotated

from agent_framework import ChatAgent, ChatClientProtocol, ai_function
from agent_framework_ag_ui import AgentFrameworkAgent
from pydantic import Field

# State schema for AG-UI shared state
STATE_SCHEMA: dict[str, object] = {
    "proverbs": {
        "type": "array",
        "items": {"type": "string"},
        "description": "Ordered list of the user's saved proverbs.",
    }
}

# Maps tool names to state fields for predictive state updates
PREDICT_STATE_CONFIG: dict[str, dict[str, str]] = {
    "proverbs": {
        "tool": "update_proverbs",
        "tool_argument": "proverbs",
    }
}

@ai_function(
    name="update_proverbs",
    description="Replace the entire list of proverbs with the provided values.",
)
def update_proverbs(
    proverbs: Annotated[
        list[str],
        Field(description="The complete source of truth for the user's proverbs."),
    ],
) -> str:
    return f"Proverbs updated. Tracking {len(proverbs)} item(s)."

@ai_function(
    name="get_weather",
    description="Share a quick weather update for a location.",
)
def get_weather(
    location: Annotated[str, Field(description="The city or region to describe.")],
) -> str:
    return f"The weather in {location.strip().title()} is mild with a light breeze."

@ai_function(
    name="go_to_moon",
    description="Request human-in-the-loop confirmation before launching.",
    approval_mode="always_require",
)
def go_to_moon() -> str:
    return "Mission control requested. Awaiting human approval."

def create_agent(chat_client: ChatClientProtocol) -> AgentFrameworkAgent:
    base_agent = ChatAgent(
        name="proverbs_agent",
        instructions=dedent("..."),  # Agent instructions
        chat_client=chat_client,
        tools=[update_proverbs, get_weather, go_to_moon],
    )
    return AgentFrameworkAgent(
        agent=base_agent,
        name="CopilotKitMicrosoftAgentFrameworkAgent",
        description="Manages proverbs, weather, and moon launches.",
        state_schema=STATE_SCHEMA,
        predict_state_config=PREDICT_STATE_CONFIG,
        require_confirmation=False,
    )

from agent_framework.openai import OpenAIChatClient
from agent_framework_ag_ui import add_agent_framework_fastapi_endpoint
from fastapi import FastAPI

chat_client = OpenAIChatClient(
    model_id=os.getenv("OPENAI_CHAT_MODEL_ID", "gpt-4o-mini"),
    api_key=os.getenv("OPENAI_API_KEY"),
)
my_agent = create_agent(chat_client)

app = FastAPI()
add_agent_framework_fastapi_endpoint(app=app, agent=my_agent, path="/")

from agent_framework.azure import AzureOpenAIChatClient
from azure.identity import DefaultAzureCredential

chat_client = AzureOpenAIChatClient(
    credential=DefaultAzureCredential(),
    deployment_name=os.getenv("AZURE_OPENAI_CHAT_DEPLOYMENT_NAME", "gpt-4o-mini"),
    endpoint=os.getenv("AZURE_OPENAI_ENDPOINT"),
)

OPENAI_API_KEY=sk-...
OPENAI_CHAT_MODEL_ID=gpt-4o-mini

AZURE_OPENAI_ENDPOINT=https://your-resource.openai.azure.com/
AZURE_OPENAI_CHAT_DEPLOYMENT_NAME=gpt-4o-mini

using Microsoft.Agents.AI;
using Microsoft.Agents.AI.Hosting.AGUI.AspNetCore;
using Microsoft.Extensions.AI;

WebApplicationBuilder builder = WebApplication.CreateBuilder(args);
builder.Services.AddAGUI();

WebApplication app = builder.Build();

var agentFactory = new ProverbsAgentFactory(builder.Configuration, ...);
app.MapAGUI("/", agentFactory.CreateProverbsAgent());

await app.RunAsync();

public class ProverbsState
{
    public List<string> Proverbs { get; set; } = [];
}

public class ProverbsAgentFactory
{
    public AIAgent CreateProverbsAgent()
    {
        var chatClient = _openAiClient.GetChatClient("gpt-4o-mini").AsIChatClient();
        var chatClientAgent = new ChatClientAgent(
            chatClient,
            name: "ProverbsAgent",
            description: "...",
            tools: [
                AIFunctionFactory.Create(GetProverbs, ...),
                AIFunctionFactory.Create(AddProverbs, ...),
                AIFunctionFactory.Create(SetProverbs, ...),
                AIFunctionFactory.Create(GetWeather, ...),
            ]);
        return new SharedStateAgent(chatClientAgent, _jsonSerializerOptions);
    }
}

cd agent
dotnet user-secrets set GitHubToken "$(gh auth token)"

import {
  CopilotRuntime,
  ExperimentalEmptyAdapter,
  copilotRuntimeNextJSAppRouterEndpoint,
} from "@copilotkit/runtime";
import { HttpAgent } from "@ag-ui/client";
import { NextRequest } from "next/server";

const runtime = new CopilotRuntime({
  agents: {
    my_agent: new HttpAgent({ url: "http://localhost:8000/" }),
  },
});

export const POST = async (req: NextRequest) => {
  const { handleRequest } = copilotRuntimeNextJSAppRouterEndpoint({
    runtime,
    serviceAdapter: new ExperimentalEmptyAdapter(),
    endpoint: "/api/copilotkit",
  });
  return handleRequest(req);
};