dotnet new console -n MyCopilotApp
cd MyCopilotApp

dotnet add package GitHub.Copilot.SDK --version 0.1.23
dotnet add package Microsoft.Extensions.AI
dotnet add package Microsoft.Extensions.Logging.Console

using GitHub.Copilot.SDK;
using Microsoft.Extensions.Logging;

using var loggerFactory = LoggerFactory.Create(b =>
    b.AddConsole().SetMinimumLevel(LogLevel.Warning));
var logger = loggerFactory.CreateLogger<CopilotClient>();

// 1. Create the client
var client = new CopilotClient(new CopilotClientOptions
{
    UseLoggedInUser = true,   // Use VS Code / gh CLI logged-in user
    Logger = logger
});

// 2. Start
await client.StartAsync();
Console.WriteLine($"State: {client.State}");

// 3. Create a session and ask a question
await using var session = await client.CreateSessionAsync(new SessionConfig
{
    Model = "gpt-4o"
});

var answer = await session.SendAndWaitAsync(
    new MessageOptions { Prompt = "What is the capital of France?" });
Console.WriteLine($"Answer: {answer?.Data.Content}");

// 4. Cleanup
await client.StopAsync();
await client.DisposeAsync();

dotnet run

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net8.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="GitHub.Copilot.SDK" Version="0.1.23" />
    <PackageReference Include="Microsoft.Extensions.AI" Version="*" />
    <PackageReference Include="Microsoft.Extensions.Logging.Console" Version="*" />
  </ItemGroup>
</Project>

var client = new CopilotClient(new CopilotClientOptions
{
    UseLoggedInUser = true,          // Use VS Code / gh CLI auth
    // GithubToken = "ghp_...",       // Or use a PAT directly
    // CliPath = "/path/to/copilot",  // Custom CLI binary path
    Logger = logger
});

var models = await client.ListModelsAsync();
foreach (var m in models)
{
    Console.WriteLine($"{m.Id,-35} {m.Name,-25} {m.Capabilities}");
}

await using var session = await client.CreateSessionAsync(new SessionConfig
{
    Model = "gpt-4o",        // Which model to use
    Streaming = true,         // Enable streaming deltas
});

// Fire-and-forget
var messageId = await session.SendAsync(new MessageOptions { Prompt = "Hello" });

// Blocking
var reply = await session.SendAndWaitAsync(new MessageOptions { Prompt = "Hello" });
Console.WriteLine(reply?.Data.Content);

var subscription = session.On(evt =>
{
    switch (evt)
    {
        case AssistantMessageDeltaEvent delta:
            Console.Write(delta.Data.DeltaContent);    // streaming token
            break;
        case AssistantMessageEvent message:
            // Complete message
            break;
        case SessionIdleEvent:
            // Model's turn is complete
            break;
        case SessionErrorEvent error:
            Console.WriteLine($"Error: {error.Data?.Message}");
            break;
    }
});

// Later: unsubscribe
subscription.Dispose();

// Create and use a session
var session1 = await client.CreateSessionAsync();
var sessionId = session1.SessionId;
await session1.SendAndWaitAsync(new MessageOptions { Prompt = "Remember: 42" });

// Resume later
var session2 = await client.ResumeSessionAsync(sessionId);
var answer = await session2.SendAndWaitAsync(
    new MessageOptions { Prompt = "What number did I mention?" });
// → "42"

// Append mode — adds after the default Copilot system prompt
new SessionConfig
{
    SystemMessage = new SystemMessageConfig
    {
        Mode = SystemMessageMode.Append,
        Content = "Always end responses with 'Have a nice day!'"
    }
}

// Replace mode — completely overrides the system prompt
new SessionConfig
{
    SystemMessage = new SystemMessageConfig
    {
        Mode = SystemMessageMode.Replace,
        Content = "You are an assistant called Testy McTestface. Reply succinctly."
    }
}

[Description("Encrypts a string by converting it to uppercase")]
static string EncryptString([Description("String to encrypt")] string input)
    => input.ToUpperInvariant();

var session = await client.CreateSessionAsync(new SessionConfig
{
    Tools = [AIFunctionFactory.Create(EncryptString, "encrypt_string")]
});

var answer = await session.SendAndWaitAsync(
    new MessageOptions { Prompt = "Encrypt: Hello World" });
// Tool is called automatically, response includes "HELLO WORLD"

var session = await client.CreateSessionAsync(new SessionConfig
{
    Tools =
    [
        AIFunctionFactory.Create(GetWeather, "get_weather"),
        AIFunctionFactory.Create(GetTime, "get_time"),
    ]
});

[Description("Gets the current weather for a city")]
static string GetWeather([Description("City name")] string city)
    => $"Weather in {city}: 22°C, partly cloudy";

[Description("Gets the current time for a city")]
static string GetTime([Description("City name")] string city)
    => $"Current time in {city}: {DateTime.UtcNow:HH:mm} UTC";

record DbQueryOptions(string Table, int[] Ids, bool SortAscending);
record City(int CountryId, string CityName, int Population);

[JsonSourceGenerationOptions(JsonSerializerDefaults.Web)]
[JsonSerializable(typeof(DbQueryOptions))]
[JsonSerializable(typeof(City[]))]
partial class DemoJsonContext : JsonSerializerContext;

City[] PerformDbQuery(DbQueryOptions query, AIFunctionArguments rawArgs)
{
    // Access ToolInvocation metadata
    var invocation = (ToolInvocation)rawArgs.Context![typeof(ToolInvocation)]!;
    // invocation.SessionId, invocation.ToolCallId, etc.
    return [new(1, "Madrid", 3223000)];
}

var tool = AIFunctionFactory.Create(PerformDbQuery, "db_query",
    serializerOptions: DemoJsonContext.Default.Options);

var failingTool = AIFunctionFactory.Create(
    () => { throw new Exception("Secret error"); },
    "get_location",
    "Gets the user's location");

// Model will NOT see "Secret error" — safe by default

// Allowlist — only these built-in tools
new SessionConfig { AvailableTools = ["view", "edit"] }

// Denylist — exclude these built-in tools
new SessionConfig { ExcludedTools = ["view"] }

var session = await client.CreateSessionAsync(new SessionConfig
{
    Tools = [myTool],
    Hooks = new SessionHooks
    {
        OnPreToolUse = (input, invocation) =>
        {
            Console.WriteLine($"Tool: {input.ToolName}, Session: {invocation.SessionId}");
            // Return "allow" or "deny"
            return Task.FromResult<PreToolUseHookOutput?>(
                new PreToolUseHookOutput { PermissionDecision = "allow" });
        }
    }
});

Hooks = new SessionHooks
{
    OnPostToolUse = (input, invocation) =>
    {
        var result = input.ToolResult?.ToString();
        Console.WriteLine($"Tool {input.ToolName} returned: {result}");
        return Task.FromResult<PostToolUseHookOutput?>(null);
    }
}

Hooks = new SessionHooks
{
    OnPreToolUse = (input, invocation) =>
    {
        Console.WriteLine($"[PRE]  → {input.ToolName}");
        return Task.FromResult<PreToolUseHookOutput?>(
            new PreToolUseHookOutput { PermissionDecision = "allow" });
    },
    OnPostToolUse = (input, invocation) =>
    {
        Console.WriteLine($"[POST] ← {input.ToolName}");
        return Task.FromResult<PostToolUseHookOutput?>(null);
    }
}

OnPreToolUse = (input, invocation) =>
{
    return Task.FromResult<PreToolUseHookOutput?>(
        new PreToolUseHookOutput { PermissionDecision = "deny" });
}
// The model will explain it couldn't access the tool

var session = await client.CreateSessionAsync(new SessionConfig
{
    OnPermissionRequest = (request, invocation) =>
    {
        Console.WriteLine($"Permission: Kind={request.Kind}, ToolCallId={request.ToolCallId}");
        // Return "approved" or "denied-interactively-by-user"
        return Task.FromResult(new PermissionRequestResult { Kind = "approved" });
    }
});

var session = await client.CreateSessionAsync(new SessionConfig
{
    OnUserInputRequest = (request, invocation) =>
    {
        Console.WriteLine($"Question: {request.Question}");

        // Choice-based prompt
        if (request.Choices is { Count: > 0 })
        {
            Console.WriteLine($"Choices: [{string.Join(", ", request.Choices)}]");
            return Task.FromResult(new UserInputResponse
            {
                Answer = request.Choices[0],   // Auto-select first
                WasFreeform = false
            });
        }

        // Freeform input
        return Task.FromResult(new UserInputResponse
        {
            Answer = "My answer",
            WasFreeform = true
        });
    }
});

var session = await client.CreateSessionAsync(new SessionConfig
{
    InfiniteSessions = new InfiniteSessionConfig
    {
        Enabled = true,
        BackgroundCompactionThreshold = 0.005,  // 0.5% → start background compaction
        BufferExhaustionThreshold = 0.01         // 1%   → block and compact
    }
});

session.On(evt =>
{
    if (evt is SessionCompactionStartEvent)
        Console.WriteLine("Compaction started!");
    if (evt is SessionCompactionCompleteEvent c)
        Console.WriteLine($"Compaction done: removed {c.Data.TokensRemoved} tokens, success={c.Data.Success}");
});

---
name: my-skill
description: A skill that adds custom behavior
---

# My Skill Instructions

Always respond in formal English.
Include a table of contents in long answers.

var session = await client.CreateSessionAsync(new SessionConfig
{
    SkillDirectories = ["/path/to/skills-dir"]
});

var session = await client.CreateSessionAsync(new SessionConfig
{
    SkillDirectories = ["/path/to/skills-dir"],
    DisabledSkills = ["my-skill"]   // Disable by name from frontmatter
});

var session = await client.CreateSessionAsync(new SessionConfig
{
    McpServers = new Dictionary<string, object>
    {
        ["my-server"] = new McpLocalServerConfig
        {
            Type = "local",
            Command = "npx",
            Args = ["-y", "@my-org/mcp-server"],
            Tools = ["*"]   // Expose all tools from this server
        }
    }
});

McpServers = new Dictionary<string, object>
{
    ["filesystem-server"] = new McpLocalServerConfig { ... },
    ["database-server"] = new McpLocalServerConfig { ... }
}

var session = await client.CreateSessionAsync(new SessionConfig
{
    CustomAgents = new List<CustomAgentConfig>
    {
        new CustomAgentConfig
        {
            Name = "business-analyst",
            DisplayName = "Business Analyst Agent",
            Description = "Specialized in business analysis",
            Prompt = "You are a business analyst. Focus on data-driven insights.",
            Infer = true   // Model decides when to use this agent
        }
    }
});

new CustomAgentConfig
{
    Name = "devops-agent",
    Tools = ["bash", "edit"],   // Only these tools available
    Infer = true
}

new CustomAgentConfig
{
    Name = "data-agent",
    McpServers = new Dictionary<string, object>
    {
        ["agent-db"] = new McpLocalServerConfig
        {
            Type = "local",
            Command = "npx",
            Args = ["-y", "@my-org/db-server"],
            Tools = ["*"]
        }
    }
}

new SessionConfig
{
    McpServers = new Dictionary<string, object>
    {
        ["shared-server"] = new McpLocalServerConfig { ... }
    },
    CustomAgents = new List<CustomAgentConfig>
    {
        new CustomAgentConfig { Name = "coordinator", ... }
    }
}

var session2 = await client.ResumeSessionAsync(sessionId, new ResumeSessionConfig
{
    McpServers = new Dictionary<string, object>
    {
        ["resume-server"] = new McpLocalServerConfig { ... }
    },
    CustomAgents = new List<CustomAgentConfig>
    {
        new CustomAgentConfig { Name = "resume-agent", ... }
    }
});

public sealed class CopilotOptions
{
    public const string SectionName = "Copilot";

    public string Model { get; set; } = "gpt-4o";
    public string? GithubToken { get; set; }
    public string? CliPath { get; set; }
    public bool UseLoggedInUser { get; set; } = true;
    public bool Streaming { get; set; } = true;
}

{
  "Copilot": {
    "Model": "gpt-4o",
    "UseLoggedInUser": true
  }
}

public sealed class CopilotChatService : IAsyncDisposable
{
    private readonly CopilotClient _client;
    private readonly CopilotOptions _options;
    private readonly ILogger<CopilotChatService> _logger;
    private readonly SemaphoreSlim _startLock = new(1, 1);
    private bool _started;

    /// <summary>Runtime-changeable model selection.</summary>
    public string CurrentModel
    {
        get => _options.Model;
        set => _options.Model = value;
    }

    /// <summary>Custom tools exposed to the Copilot SDK.</summary>
    public IReadOnlyList<AIFunction>? Tools { get; set; }

    /// <summary>Optional system message appended to the session.</summary>
    public string? SystemMessage { get; set; }

    public CopilotChatService(
        IOptions<CopilotOptions> optionsAccessor,
        ILogger<CopilotChatService> logger)
    {
        _options = optionsAccessor?.Value ?? new CopilotOptions();
        _logger = logger;
        _client = new CopilotClient(new CopilotClientOptions
        {
            CliPath = string.IsNullOrWhiteSpace(_options.CliPath) ? null : _options.CliPath,
            GithubToken = string.IsNullOrWhiteSpace(_options.GithubToken) ? null : _options.GithubToken,
            UseLoggedInUser = string.IsNullOrWhiteSpace(_options.GithubToken)
                              && _options.UseLoggedInUser,
            Logger = logger
        });
    }

    private async Task EnsureStartedAsync()
    {
        if (_started) return;
        await _startLock.WaitAsync().ConfigureAwait(false);
        try
        {
            if (_started) return;
            await _client.StartAsync().ConfigureAwait(false);
            _started = true;
        }
        finally { _startLock.Release(); }
    }

    public async Task<string> AskAsync(
        string prompt, CancellationToken cancellationToken = default)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(prompt);
        await EnsureStartedAsync().ConfigureAwait(false);

        // ── Build session config ──────────────────────────────
        var config = new SessionConfig
        {
            Model = _options.Model,
            Streaming = true,
        };
        if (Tools is { Count: > 0 })
            config.Tools = Tools.ToList();
        if (!string.IsNullOrWhiteSpace(SystemMessage))
            config.SystemMessage = new SystemMessageConfig
            {
                Mode = SystemMessageMode.Append,
                Content = SystemMessage
            };

        // ── Create session, send, collect via events ──────────
        await using var session = await _client
            .CreateSessionAsync(config).ConfigureAwait(false);

        var buffer = new StringBuilder();
        string? lastError = null;
        var idleTcs = new TaskCompletionSource<bool>(
            TaskCreationOptions.RunContinuationsAsynchronously);

        var subscription = session.On(evt =>
        {
            switch (evt)
            {
                case AssistantMessageDeltaEvent delta:
                    buffer.Append(delta.Data.DeltaContent);
                    break;
                case SessionErrorEvent error:
                    lastError = error.Data?.Message ?? "Unknown session error";
                    _logger.LogError("[SessionError] {Message}", lastError);
                    idleTcs.TrySetResult(false);
                    break;
                case SessionIdleEvent:
                    idleTcs.TrySetResult(true);
                    break;
            }
        });

        try
        {
            using var cts = CancellationTokenSource
                .CreateLinkedTokenSource(cancellationToken);
            cts.CancelAfter(TimeSpan.FromMinutes(2));

            try
            {
                await session.SendAsync(new MessageOptions { Prompt = prompt })
                    .WaitAsync(cts.Token).ConfigureAwait(false);
                await idleTcs.Task.WaitAsync(cts.Token).ConfigureAwait(false);
            }
            catch (OperationCanceledException)
                when (!cancellationToken.IsCancellationRequested)
            {
                _logger.LogWarning("[AskAsync] Timed out. Buffer: {Len}", buffer.Length);
            }

            if (buffer.Length > 0)
                return buffer.ToString();
            if (lastError != null)
                return $"Error: {lastError}";
            return "No response received from the AI model. Please try again.";
        }
        finally { subscription.Dispose(); }
    }

    /// <summary>
    /// Streams response deltas. In SDK v0.1.x, true delta streaming
    /// through session events is unreliable when tool calls are involved,
    /// so this yields the complete response as a single chunk.
    /// </summary>
    public async IAsyncEnumerable<string> AskStreamingAsync(
        string prompt,
        [EnumeratorCancellation] CancellationToken cancellationToken = default)
    {
        var response = await AskAsync(prompt, cancellationToken)
            .ConfigureAwait(false);
        if (!string.IsNullOrEmpty(response))
            yield return response;
    }

    public async ValueTask DisposeAsync()
    {
        if (_started)
        {
            try { await _client.StopAsync().ConfigureAwait(false); }
            catch (Exception ex)
            {
                _logger.LogWarning(ex, "Failed to stop Copilot client cleanly.");
            }
        }
        await _client.DisposeAsync().ConfigureAwait(false);
        _startLock.Dispose();
    }
}

public sealed class CopilotChatClient : IChatClient
{
    private readonly CopilotChatService _service;

    public CopilotChatClient(CopilotChatService service)
    {
        _service = service ?? throw new ArgumentNullException(nameof(service));
    }

    public ChatClientMetadata Metadata => new("CopilotChat");

    public async Task<ChatResponse> GetResponseAsync(
        IEnumerable<ChatMessage> chatMessages,
        ChatOptions? options = null,
        CancellationToken cancellationToken = default)
    {
        // Extract the last user message as the prompt
        var lastUserMessage = chatMessages
            .LastOrDefault(m => m.Role == ChatRole.User);
        var prompt = lastUserMessage?.Text ?? string.Empty;

        var response = await _service.AskAsync(prompt, cancellationToken);
        return new ChatResponse(new ChatMessage(ChatRole.Assistant, response));
    }

    public async IAsyncEnumerable<ChatResponseUpdate> GetStreamingResponseAsync(
        IEnumerable<ChatMessage> chatMessages,
        ChatOptions? options = null,
        [EnumeratorCancellation] CancellationToken cancellationToken = default)
    {
        var lastUserMessage = chatMessages
            .LastOrDefault(m => m.Role == ChatRole.User);
        var prompt = lastUserMessage?.Text ?? string.Empty;

        await foreach (var chunk in _service
            .AskStreamingAsync(prompt, cancellationToken)
            .ConfigureAwait(false))
        {
            yield return new ChatResponseUpdate
            {
                Role = ChatRole.Assistant,
                Contents = [new TextContent(chunk)]
            };
        }
    }

    public object? GetService(Type serviceType, object? serviceKey = null)
        => serviceType == typeof(CopilotChatClient) ? this : null;

    public void Dispose() { }
}

public sealed class MyToolsProvider
{
    private readonly IServiceProvider _serviceProvider;
    private List<AIFunction>? _tools;

    public MyToolsProvider(IServiceProvider serviceProvider)
    {
        _serviceProvider = serviceProvider;
    }

    public IReadOnlyList<AIFunction> Tools => _tools ??= CreateTools();

    private List<AIFunction> CreateTools() =>
    [
        AIFunctionFactory.Create(GetWeather, "get_weather"),
        AIFunctionFactory.Create(GetTime, "get_time"),
        AIFunctionFactory.Create(QueryDatabase, "query_database"),
    ];

    [Description("Gets the current weather for a city")]
    private string GetWeather(
        [Description("City name")] string city)
        => $"Weather in {city}: 22°C, partly cloudy";

    [Description("Gets the current time for a city")]
    private string GetTime(
        [Description("City name")] string city)
        => $"Current time in {city}: {DateTime.UtcNow:HH:mm} UTC";

    [Description("Queries the database for records")]
    private string QueryDatabase(
        [Description("Table name")] string table,
        [Description("Search term")] string search = "")
    {
        // Use DI to get a DbContext, IObjectSpace, etc.
        using var scope = _serviceProvider.CreateScope();
        var db = scope.ServiceProvider.GetRequiredService<MyDbContext>();
        // ... query and return results as string
        return "Query results...";
    }
}

public static class ServiceCollectionExtensions
{
    public static IServiceCollection AddCopilotSdk(
        this IServiceCollection services,
        IConfiguration configuration)
    {
        ArgumentNullException.ThrowIfNull(services);
        ArgumentNullException.ThrowIfNull(configuration);

        // 1. Bind options from appsettings.json
        services.Configure<CopilotOptions>(
            configuration.GetSection(CopilotOptions.SectionName));

        // 2. Register the service (singleton — manages CopilotClient lifecycle)
        services.AddSingleton<CopilotChatService>();

        // 3. Register the tools provider
        services.AddSingleton<MyToolsProvider>();

        // 4. Register the IChatClient adapter
        services.AddChatClient(sp =>
        {
            var service = sp.GetRequiredService<CopilotChatService>();
            var toolsProvider = sp.GetRequiredService<MyToolsProvider>();

            // Wire tools and system message into the service
            service.Tools = toolsProvider.Tools;
            service.SystemMessage = "You are a helpful assistant.";

            return new CopilotChatClient(service);
        });

        return services;
    }
}

var builder = WebApplication.CreateBuilder(args);

// Register all Copilot SDK services + IChatClient
builder.Services.AddCopilotSdk(builder.Configuration);

// ... rest of your app setup
var app = builder.Build();
app.Run();

public static class CopilotChatDefaults
{
    private static readonly MarkdownPipeline Pipeline = new MarkdownPipelineBuilder()
        .UsePipeTables()
        .UseEmphasisExtras()
        .UseAutoLinks()
        .UseTaskLists()
        .Build();

    private static readonly HtmlSanitizer Sanitizer = CreateSanitizer();

    private static HtmlSanitizer CreateSanitizer()
    {
        var sanitizer = new HtmlSanitizer();
        foreach (var tag in new[] { "table", "thead", "tbody", "tr", "th", "td" })
            sanitizer.AllowedTags.Add(tag);
        return sanitizer;
    }

    /// <summary>
    /// Converts Markdown to sanitized HTML. Thread-safe.
    /// </summary>
    public static string ConvertMarkdownToHtml(string markdown)
    {
        if (string.IsNullOrEmpty(markdown))
            return string.Empty;

        var html = Markdown.ToHtml(markdown, Pipeline);
        return Sanitizer.Sanitize(html);
    }
}

dotnet add package Markdig --version "0.38.*"
dotnet add package HtmlSanitizer --version "8.*"

public static class CopilotChatDefaults
{
    public const string HeaderText = "Copilot Assistant";

    public const string EmptyStateText =
        "Ask me anything about your data.\nPowered by GitHub Copilot SDK.";

    public record PromptSuggestionItem(string Title, string Text, string Prompt);

    public static IReadOnlyList<PromptSuggestionItem> PromptSuggestions { get; } =
    [
        new("Weather", "Check the weather", "What's the weather in Madrid?"),
        new("Time", "Check the time", "What time is it in Tokyo?"),
        new("Help", "What can you do?", "What tools do you have available?"),
    ];

    public const string SystemPrompt = """
        You are a helpful assistant.
        When answering:
        - Use Markdown formatting.
        - Be concise but thorough.
        """;

    // ... ConvertMarkdownToHtml (see above)
}

var client = new CopilotClient(new CopilotClientOptions
{
    UseLoggedInUser = true,
    Logger = logger
});
await client.StartAsync();

await using var session = await client.CreateSessionAsync(new SessionConfig
{
    Streaming = true,
    Tools =
    [
        AIFunctionFactory.Create(GetWeather, "get_weather"),
        AIFunctionFactory.Create(GetTime, "get_time"),
    ]
});

Console.WriteLine("Type messages (empty to quit):\n");
while (true)
{
    Console.Write("You: ");
    var input = Console.ReadLine();
    if (string.IsNullOrWhiteSpace(input)) break;

    var done = new TaskCompletionSource<bool>();
    var sub = session.On(evt =>
    {
        if (evt is AssistantMessageDeltaEvent d)
            Console.Write(d.Data.DeltaContent);
        if (evt is SessionIdleEvent)
            done.TrySetResult(true);
        if (evt is SessionErrorEvent err)
        {
            Console.WriteLine($"\nError: {err.Data?.Message}");
            done.TrySetResult(false);
        }
    });

    Console.Write("AI: ");
    await session.SendAsync(new MessageOptions { Prompt = input });
    await done.Task.WaitAsync(TimeSpan.FromMinutes(2));
    Console.WriteLine();
    sub.Dispose();
}

await client.StopAsync();
await client.DisposeAsync();

using MyApp.Services;
using Microsoft.EntityFrameworkCore;

var builder = WebApplication.CreateBuilder(args);

// EF Core (optional — for tool database access)
builder.Services.AddDbContextFactory<MyDbContext>(options =>
    options.UseSqlite("Data Source=app.db"));

// GitHub Copilot SDK → IChatClient
builder.Services.AddCopilotSdk(builder.Configuration);

// DevExpress AI integration (registers DxAIChat component)
builder.Services.AddDevExpressAI();

// Blazor
builder.Services.AddRazorComponents()
    .AddInteractiveServerComponents();

var app = builder.Build();

app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseAntiforgery();
app.MapRazorComponents<App>()
    .AddInteractiveServerRenderMode();

app.Run();

{
  "Copilot": {
    "Model": "gpt-4o",
    "UseLoggedInUser": true,
    "Streaming": true
  }
}

var service = serviceProvider.GetRequiredService<CopilotChatService>();
service.CurrentModel = "claude-sonnet-4";
// Next AskAsync call will use Claude

[JsonSourceGenerationOptions(JsonSerializerDefaults.Web)]
[JsonSerializable(typeof(MyInputType))]
[JsonSerializable(typeof(MyOutputType))]
partial class MyJsonContext : JsonSerializerContext;

var tool = AIFunctionFactory.Create(MyMethod, "my_tool",
    serializerOptions: MyJsonContext.Default.Options);

using Microsoft.Extensions.AI;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using System.ComponentModel;
using System.Runtime.CompilerServices;
using System.Text;
using GitHub.Copilot.SDK;

// ── DI Setup ──────────────────────────────────────────────────────────
var services = new ServiceCollection();
services.AddLogging(b => b.AddConsole().SetMinimumLevel(LogLevel.Warning));

// Configure options manually (no appsettings.json in console)
services.Configure<CopilotOptions>(o =>
{
    o.Model = "gpt-4o";
    o.UseLoggedInUser = true;
});

services.AddSingleton<CopilotChatService>();

// Register IChatClient via the adapter
services.AddSingleton<IChatClient>(sp =>
{
    var svc = sp.GetRequiredService<CopilotChatService>();

    // Wire tools
    svc.Tools =
    [
        AIFunctionFactory.Create(GetWeather, "get_weather"),
        AIFunctionFactory.Create(GetTime, "get_time"),
    ];
    svc.SystemMessage = "You are a helpful assistant. Use Markdown formatting.";

    return new CopilotChatClient(svc);
});

var provider = services.BuildServiceProvider();

// ── Use IChatClient ───────────────────────────────────────────────────
var chatClient = provider.GetRequiredService<IChatClient>();

var messages = new List<ChatMessage>
{
    new(ChatRole.User, "What's the weather in Tokyo and what time is it?")
};

var response = await chatClient.GetResponseAsync(messages);
Console.WriteLine($"Response: {response.Message.Text}");

// ── Cleanup ───────────────────────────────────────────────────────────
await provider.DisposeAsync();

// ── Tool implementations ──────────────────────────────────────────────
[Description("Gets the current weather for a city")]
static string GetWeather([Description("City name")] string city)
    => $"Weather in {city}: 22°C, partly cloudy, humidity 65%";

[Description("Gets the current time for a city")]
static string GetTime([Description("City name")] string city)
    => $"Current time in {city}: {DateTime.UtcNow:HH:mm} UTC";

// ── Supporting classes (normally in separate files) ────────────────────

public sealed class CopilotOptions
{
    public const string SectionName = "Copilot";
    public string Model { get; set; } = "gpt-4o";
    public string? GithubToken { get; set; }
    public string? CliPath { get; set; }
    public bool UseLoggedInUser { get; set; } = true;
    public bool Streaming { get; set; } = true;
}

public sealed class CopilotChatService : IAsyncDisposable
{
    private readonly CopilotClient _client;
    private readonly CopilotOptions _options;
    private readonly ILogger<CopilotChatService> _logger;
    private readonly SemaphoreSlim _startLock = new(1, 1);
    private bool _started;

    public string CurrentModel { get => _options.Model; set => _options.Model = value; }
    public IReadOnlyList<AIFunction>? Tools { get; set; }
    public string? SystemMessage { get; set; }

    public CopilotChatService(IOptions<CopilotOptions> opts, ILogger<CopilotChatService> logger)
    {
        _options = opts?.Value ?? new CopilotOptions();
        _logger = logger;
        _client = new CopilotClient(new CopilotClientOptions
        {
            CliPath = string.IsNullOrWhiteSpace(_options.CliPath) ? null : _options.CliPath,
            GithubToken = string.IsNullOrWhiteSpace(_options.GithubToken) ? null : _options.GithubToken,
            UseLoggedInUser = string.IsNullOrWhiteSpace(_options.GithubToken) && _options.UseLoggedInUser,
            Logger = logger
        });
    }

    private async Task EnsureStartedAsync()
    {
        if (_started) return;
        await _startLock.WaitAsync();
        try { if (!_started) { await _client.StartAsync(); _started = true; } }
        finally { _startLock.Release(); }
    }

    public async Task<string> AskAsync(string prompt, CancellationToken ct = default)
    {
        await EnsureStartedAsync();
        var config = new SessionConfig { Model = _options.Model, Streaming = true };
        if (Tools is { Count: > 0 }) config.Tools = Tools.ToList();
        if (!string.IsNullOrWhiteSpace(SystemMessage))
            config.SystemMessage = new SystemMessageConfig
            { Mode = SystemMessageMode.Append, Content = SystemMessage };

        await using var session = await _client.CreateSessionAsync(config);
        var buf = new StringBuilder();
        string? err = null;
        var idle = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
        var sub = session.On(e =>
        {
            if (e is AssistantMessageDeltaEvent d) buf.Append(d.Data.DeltaContent);
            if (e is SessionErrorEvent se) { err = se.Data?.Message; idle.TrySetResult(false); }
            if (e is SessionIdleEvent) idle.TrySetResult(true);
        });
        try
        {
            using var cts = CancellationTokenSource.CreateLinkedTokenSource(ct);
            cts.CancelAfter(TimeSpan.FromMinutes(2));
            await session.SendAsync(new MessageOptions { Prompt = prompt }).WaitAsync(cts.Token);
            await idle.Task.WaitAsync(cts.Token);
        }
        catch (OperationCanceledException) when (!ct.IsCancellationRequested) { }
        finally { sub.Dispose(); }
        return buf.Length > 0 ? buf.ToString() : err ?? "No response.";
    }

    public async IAsyncEnumerable<string> AskStreamingAsync(
        string prompt, [EnumeratorCancellation] CancellationToken ct = default)
    {
        var r = await AskAsync(prompt, ct);
        if (!string.IsNullOrEmpty(r)) yield return r;
    }

    public async ValueTask DisposeAsync()
    {
        if (_started) try { await _client.StopAsync(); } catch { }
        await _client.DisposeAsync();
        _startLock.Dispose();
    }
}

public sealed class CopilotChatClient : IChatClient
{
    private readonly CopilotChatService _svc;
    public CopilotChatClient(CopilotChatService svc) => _svc = svc;
    public ChatClientMetadata Metadata => new("CopilotChat");

    public async Task<ChatResponse> GetResponseAsync(
        IEnumerable<ChatMessage> msgs, ChatOptions? opt = null, CancellationToken ct = default)
    {
        var prompt = msgs.LastOrDefault(m => m.Role == ChatRole.User)?.Text ?? "";
        var resp = await _svc.AskAsync(prompt, ct);
        return new ChatResponse(new ChatMessage(ChatRole.Assistant, resp));
    }

    public async IAsyncEnumerable<ChatResponseUpdate> GetStreamingResponseAsync(
        IEnumerable<ChatMessage> msgs, ChatOptions? opt = null,
        [EnumeratorCancellation] CancellationToken ct = default)
    {
        var prompt = msgs.LastOrDefault(m => m.Role == ChatRole.User)?.Text ?? "";
        await foreach (var c in _svc.AskStreamingAsync(prompt, ct))
            yield return new ChatResponseUpdate
            { Role = ChatRole.Assistant, Contents = [new TextContent(c)] };
    }

    public object? GetService(Type t, object? k = null) => t == typeof(CopilotChatClient) ? this : null;
    public void Dispose() { }
}