# Using your preferred agentic experience
> Evaluate my plugin based on its configuration 
 
# Or using the CLI
wiqd agent eval init
wiqd agent eval

using ModelContextProtocol.Server;
using System.ComponentModel;
 
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddMcpServer()
    .WithHttpTransport()   // stateless by default now
    .WithToolsFromAssembly();
 
var app = builder.Build();
app.MapMcp();
app.Run("http://localhost:3001");
 
[McpServerToolType]
public static class EchoTool
{
    [McpServerTool, Description("Echoes the message back to the client.")]
    public static string Echo(string message) => $"hello {message}";
}

[McpServerTool(Name = "get_order_status"),
 Description("Gets order status from the regional orders service")]
public static async Task<string> GetOrderStatus(
    OrdersServiceClient orders,
    [McpHeader("Region"), Description("Orders service region")] string region,
    [Description("The order to look up")] string orderId)
{
    // The client mirrors `region` into a request header:
    //   Mcp-Param-Region: eastus2
    return await orders.GetStatusAsync(region, orderId);
}

[McpServerTool, Description("Closes a support ticket, recording why it was closed.")]
public static string CloseSupportTicket(
    McpServer server,
    RequestContext<CallToolRequestParams> context,
    [Description("The ID of the ticket to close")] long ticketId,
    [Description("Why the ticket is being closed")] string? closeReason = null)
{
    // Handles four client scenarios:
    //  1. Provided up-front: client sends `closeReason` in the initial call
    //  2. MRTR round-trip request: client confirms via `InputResponses["closeReason"]`
    //  3. MRTR initial request: server proposes a default reason and asks for confirmation
    //     (with automatic SDK down-level bridge)
    //  4. Session-less down-level: server returns a guidance message requesting the reason up-front
 
    // The default reason proposed to the caller and used if none is provided.
    string defaultCloseReason = "completed";
 
    // (1) Provided up-front. Works on any client, including down-level session-less.
    //     These requests are typically sent after (4) returns a guidance message.
    var confirmedReason = closeReason;
 
    // (2) MRTR round-trip request. Works with native MRTR support or the automatic down-level
    //     SDK bridge after (3) throws an `InputRequiredException` to request a `closeReason`.
    if (string.IsNullOrWhiteSpace(confirmedReason) &&
        context.Params?.InputResponses?.TryGetValue("closeReason", out var reasonResponse) is true)
    {
        var reasonResult = reasonResponse.Deserialize(InputResponse.ElicitResultJsonTypeInfo);
 
        // Branch on the elicitation action: `decline` or `cancel` leaves the ticket open.
        if (reasonResult?.IsAccepted is not true) return "Ticket close cancelled";
 
        // Accepted: use the reason the caller confirmed, falling back to the proposed default.
        confirmedReason = reasonResult.Content?.TryGetValue("closeReason", out var reasonValue) is true
            ? reasonValue.GetString()
            : null;
        confirmedReason = string.IsNullOrWhiteSpace(confirmedReason) ? defaultCloseReason : confirmedReason;
    }
 
    // (1) or (2) A reason is in hand; proceed with closing the ticket.
    if (!string.IsNullOrWhiteSpace(confirmedReason))
        return $"Closed ticket {ticketId}: {confirmedReason}";
 
    // (3) MRTR initial request: propose "completed" as the default reason and ask the caller
    //     to confirm (or adjust) it. This uses the 2026-07-28 MRTR input request, but the SDK
    //     provides an automatic bridge to a legacy elicitation on a down-level, stateful
    //     session. When the bridge can be provided, `server.IsMrtrSupported` is `true` and the
    //     exception leads to a legacy elicitation response automatically.
    if (server.IsMrtrSupported)
    {
        throw new InputRequiredException(
            inputRequests: new Dictionary<string, InputRequest>
            {
                ["closeReason"] = InputRequest.ForElicitation(new ElicitRequestParams
                {
                    Message = $"Close ticket '{ticketId}'? Accept the default reason or provide your own.",
                    RequestedSchema = new()
                    {
                        Properties =
                        {
                            ["closeReason"] = new ElicitRequestParams.StringSchema
                            {
                                Title = "Close reason",
                                Description = "The reason for closing the ticket",
                                Default = defaultCloseReason,
                            },
                        },
                    },
                })
            },
            requestState: ticketId.ToString());   // opaque; echoed back to us on the retry
    }
 
    // (4) Down-level and stateless: we can't prompt an elicitation through an MRTR
    //     round-trip request or an elicitation. Return a natural language response
    //     with guidance for providing the reason up-front.
    return "Closing a ticket requires a reason. Resend with `closeReason`.";
}

var client = await McpClient.CreateAsync(
    clientTransport,
    clientOptions: new()
    {
        Handlers = new McpClientHandlers
        {
            ElicitationHandler = (requestParams, ct) =>
            {
                // Accept the proposed default close reason.
                return ValueTask.FromResult(new ElicitResult { Action = "accept" });
            },
        }
    });
 
// The client transparently handles the input_required round trip.
var result = await client.CallToolAsync(
    "close_support_ticket",
    new Dictionary<string, object?> { ["ticketId"] = 1234L },
    cancellationToken: CancellationToken.None);

# Most servers:
dotnet add package ModelContextProtocol
 
# HTTP servers:
dotnet add package ModelContextProtocol.AspNetCore
 
# Just a client, or the low-level API:
dotnet add package ModelContextProtocol.Core

public record class Cat(string Name);
public record class Dog(string Name);
public record class Bird(string Name);
 
public union Pet(Cat, Dog, Bird);

Pet pet = new Dog("Rex");
Console.WriteLine(pet.Value); // Dog { Name = Rex }
 
Pet pet2 = new Cat("Whiskers");
Console.WriteLine(pet2.Value); // Cat { Name = Whiskers }

string name = pet switch
{
    Dog d => d.Name,
    Cat c => c.Name,
    Bird b => b.Name,
};

Pet pet = default;
 
var description = pet switch
{
    Dog d => d.Name,
    Cat c => c.Name,
    Bird b => b.Name,
    null => "no pet",
};
// description is "no pet"

public union OneOrMore<T>(T, IEnumerable<T>)
{
    public IEnumerable<T> AsEnumerable() => Value switch
    {
        T single => [single],
        IEnumerable<T> multiple => multiple,
        null => []
    };
}

OneOrMore<string> tags = "dotnet";
OneOrMore<string> moreTags = new[] { "csharp", "unions", "preview" };
 
foreach (var tag in tags.AsEnumerable())
    Console.Write($"[{tag}] ");
// [dotnet]
 
foreach (var tag in moreTags.AsEnumerable())
    Console.Write($"[{tag}] ");
// [csharp] [unions] [preview]

namespace System.Runtime.CompilerServices
{
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct,
        AllowMultiple = false)]
    public sealed class UnionAttribute : Attribute;

    public interface IUnion
    {
        object? Value { get; }
    }
}

public record class Cat(string Name);
public record class Dog(string Name);
 
public union Pet(Cat, Dog);
 
Pet pet = new Cat("Whiskers");
Console.WriteLine(pet switch
{
    Cat c => $"Cat: {c.Name}",
    Dog d => $"Dog: {d.Name}",
});

# pip install agent-framework
# Use `az login` to authenticate with Azure CLI
 
import asyncio
 
from agent_framework import Agent
from agent_framework.foundry import FoundryChatClient
from azure.identity import AzureCliCredential
 
agent = Agent(
*** client= FoundryChatClient(
**** *project_endpoint="https://your-project.services.ai.azure.com",
***** model="gpt-5.3",
* ****credential=AzureCliCredential(),
*** ),
*** name="HelloAgent",
*** instructions="You are a friendly assistant."
)
 
print(asyncio.run(agent.run("Write a haiku about shipping 1.0.")))

// dotnet add package Microsoft.Agents.AI.OpenAI --prerelease
using Microsoft.Agents.AI;
using Microsoft.Agents.AI.Foundry
using Azure.Identity;
 
// Replace the <apikey> with your OpenAI API key.
var agent = new AIProjectClient(endpoint:"https://your-project.services.ai.azure.com")
*** .GetResponsesClient("gpt-5.3")
*** .AsAIAgent(
        name: "HaikuBot", 
        instructions: "You are an upbeat assistant that writes beautifully."
    );
 
Console.WriteLine(await agent.RunAsync("Write a haiku about shipping 1.0."));

import asyncio
 
from agent_framework import Agent, Message
from agent_framework.foundry import FoundryChatClient
from agent_framework.orchestrations import SequentialBuilder
from azure.identity import AzureCliCredential
 
 
async def main() -> None:
*** # credentials read from .env
*** client = FoundryChatClient(credential=AzureCliCredential())
 
*** writer = Agent(
******* client=client,
******* instructions="You are a concise copywriter. Provide a single, punchy marketing sentence.",
******* name="writer",
*** )
 
*** reviewer = Agent(
******* client=client,
******* instructions="You are a thoughtful reviewer. Give brief feedback on the previous message.",
******* name="reviewer",
*** )
 
 
*** workflow = SequentialBuilder(participants=[writer, reviewer]).build()
*** outputs: list[list[Message]] = []
*** async for event in workflow.run("Write a tagline for Microsoft Agent Framework 1.0.", stream=True):
******* if event.type == "output":
*********** outputs.append(cast(list[Message], event.data))
*** if outputs:
******* for msg in outputs[-1]:
*********** print(f"[{msg.author_name or 'user'}]: {msg.text}")
 
if __name__ == "__main__":
*** asyncio.run(main())