GitHub Copilot

Wprowadzenie

Dodaj wymagane pakiety NuGet do projektu.

dotnet add package Microsoft.Agents.AI.GitHub.Copilot

Tworzenie agenta Copilot w usłudze GitHub

Na początku utwórz CopilotClient i uruchom go. Następnie użyj AsAIAgent metody rozszerzenia, aby utworzyć agenta.

using GitHub.Copilot;
using Microsoft.Agents.AI;

await using CopilotClient copilotClient = new();
await copilotClient.StartAsync();

AIAgent agent = copilotClient.AsAIAgent(sessionConfig: null);

Console.WriteLine(await agent.RunAsync("What is Microsoft Agent Framework?"));

Za pomocą narzędzi i instrukcji

Podczas tworzenia agenta można udostępnić narzędzia funkcji i instrukcje niestandardowe:

using GitHub.Copilot;
using Microsoft.Agents.AI;
using Microsoft.Extensions.AI;

AIFunction weatherTool = AIFunctionFactory.Create((string location) =>
{
    return $"The weather in {location} is sunny with a high of 25C.";
}, "GetWeather", "Get the weather for a given location.");

await using CopilotClient copilotClient = new();
await copilotClient.StartAsync();

AIAgent agent = copilotClient.AsAIAgent(
    tools: [weatherTool],
    instructions: "You are a helpful weather agent.");

Console.WriteLine(await agent.RunAsync("What's the weather like in Seattle?"));

Funkcje agenta

Odpowiedzi w strumieniowaniu

Pobierz odpowiedzi w miarę ich generowania:

await using CopilotClient copilotClient = new();
await copilotClient.StartAsync();

AIAgent agent = copilotClient.AsAIAgent(sessionConfig: null);

await foreach (AgentResponseUpdate update in agent.RunStreamingAsync("Tell me a short story."))
{
    Console.Write(update);
}

Console.WriteLine();

Zarządzanie sesjami

Zachowaj kontekst konwersacji w wielu interakcjach przy użyciu sesji:

await using CopilotClient copilotClient = new();
await copilotClient.StartAsync();

await using GitHubCopilotAgent agent = new(
    copilotClient,
    instructions: "You are a helpful assistant. Keep your answers short.");

AgentSession session = await agent.CreateSessionAsync();

// First turn
await agent.RunAsync("My name is Alice.", session);

// Second turn - agent remembers the context
AgentResponse response = await agent.RunAsync("What is my name?", session);
Console.WriteLine(response); // Should mention "Alice"

Permissions

Domyślnie agent nie może wykonywać poleceń powłoki, odczytywać/zapisywać plików ani pobierać URL-i. Aby włączyć te możliwości, podaj procedurę obsługi uprawnień za pomocą polecenia SessionConfig:

static Task<PermissionDecision> PromptPermission(
    PermissionRequest request, PermissionInvocation invocation)
{
    Console.WriteLine($"\n[Permission Request: {request.Kind}]");
    Console.Write("Approve? (y/n): ");

    string? input = Console.ReadLine()?.Trim().ToUpperInvariant();
    PermissionDecision decision = input is "Y" or "YES"
        ? PermissionDecision.ApproveOnce()
        : PermissionDecision.Reject();

    return Task.FromResult(decision);
}

await using CopilotClient copilotClient = new();
await copilotClient.StartAsync();

SessionConfig sessionConfig = new()
{
    OnPermissionRequest = PromptPermission,
};

AIAgent agent = copilotClient.AsAIAgent(sessionConfig);

Console.WriteLine(await agent.RunAsync("List all files in the current directory"));

Zatwierdzanie narzędzi

Ponieważ zestaw SDK GitHub Copilot kontroluje pętlę wywoływania narzędzi, zatwierdzanie niestandardowych narzędzi funkcyjnych odbywa się za pośrednictwem natywnego haka przed wykonaniem w tym SDK, a nie standardowego mechanizmu zatwierdzania w Agent Framework. Gdy zarejestrujesz narzędzie opakowane w ApprovalRequiredAIFunction, agent instaluje domyślny hook OnPreToolUse, który zwraca "ask" dla tego narzędzia i przekazuje decyzję do procedury obsługi OnPermissionRequest:

using GitHub.Copilot;
using Microsoft.Agents.AI;
using Microsoft.Extensions.AI;

AIFunction deleteFile = AIFunctionFactory.Create(
    (string path) => $"Deleted {path}.",
    "DeleteFile",
    "Deletes a file.");

await using CopilotClient copilotClient = new();
await copilotClient.StartAsync();

SessionConfig sessionConfig = new()
{
    // Wrapping the tool marks it approval-required; the agent turns this into an "ask" at OnPreToolUse.
    Tools = [new ApprovalRequiredAIFunction(deleteFile)],

    // OnPermissionRequest decides the "asked" tools (and Copilot's built-in shell/file/URL prompts).
    OnPermissionRequest = PromptPermission,
};

AIAgent agent = copilotClient.AsAIAgent(sessionConfig);

Console.WriteLine(await agent.RunAsync("Delete the file temp.txt"));

Serwery MCP

Nawiąż połączenie z lokalnymi (stdio) lub zdalnymi serwerami MCP (HTTP), aby uzyskać rozszerzone możliwości:

await using CopilotClient copilotClient = new();
await copilotClient.StartAsync();

SessionConfig sessionConfig = new()
{
    OnPermissionRequest = PromptPermission,
    McpServers = new Dictionary<string, McpServerConfig>
    {
        // Local stdio server
        ["filesystem"] = new McpStdioServerConfig
        {
            Command = "npx",
            Args = ["-y", "@modelcontextprotocol/server-filesystem", "."],
            Tools = ["*"],
        },
        // Remote HTTP server
        ["microsoft-learn"] = new McpHttpServerConfig
        {
            Url = "https://learn.microsoft.com/api/mcp",
            Tools = ["*"],
        },
    },
};

AIAgent agent = copilotClient.AsAIAgent(sessionConfig);

Console.WriteLine(await agent.RunAsync("Search Microsoft Learn for 'Azure Functions' and summarize the top result"));

Tools

Korzystanie z agenta

Agent jest standardowy AIAgent i obsługuje wszystkie standardowe AIAgent operacje.

Aby uzyskać więcej informacji na temat uruchamiania agentów i interakcji z nimi, zobacz samouczki wprowadzające do agenta.

Wymagania wstępne

Zainstaluj pakiet GitHub Copilot programu Microsoft Agent Framework.

pip install agent-framework-github-copilot

Configuration

Agent można opcjonalnie skonfigurować przy użyciu następujących zmiennych środowiskowych:

Wprowadzenie

Zaimportuj wymagane klasy z programu Agent Framework:

import asyncio
from agent_framework.github import GitHubCopilotAgent, GitHubCopilotOptions

Tworzenie agenta Copilot w usłudze GitHub

Tworzenie podstawowego agenta

Najprostszy sposób na stworzenie agenta GitHub Copilot:

async def basic_example():
    agent = GitHubCopilotAgent(
        instructions="You are a helpful assistant.",
    )

    async with agent:
        result = await agent.run("What is Microsoft Agent Framework?")
        print(result)

Z jawną konfiguracją

Konfigurację jawną można podać za pomocą elementu default_options:

async def explicit_config_example():
    agent = GitHubCopilotAgent(
        instructions="You are a helpful assistant.",
        default_options={
            "model": "gpt-5",
            "timeout": 120,
        },
    )

    async with agent:
        result = await agent.run("What can you do?")
        print(result)

Przynieś swój własny klucz (BYOK)

Użyj funkcji BYOK w zestawie SDK Copilot, aby kierować żądania do modelu przez własny punkt końcowy OpenAI, Azure OpenAI, Anthropic lub zgodny z OpenAI zamiast przez zaplecze GitHub Copilot. Przekaż ProviderConfig przez GitHubCopilotOptions(provider=...) i ustaw ten sam identyfikator modelu zarówno w konfiguracji dostawcy, jak i w opcji model na poziomie sesji.

W przykładzie z możliwością uruchomienia są używane następujące zmienne środowiskowe:

import asyncio
import os
from typing import Literal, cast

from agent_framework.github import GitHubCopilotAgent, GitHubCopilotOptions
from copilot.session import ProviderConfig


async def main() -> None:
    print("=== GitHub Copilot Agent with BYOK (Bring Your Own Key) ===\n")

    model_id = os.environ.get("BYOK_MODEL_ID", "gpt-4o")
    provider_type = cast(Literal["openai", "azure", "anthropic"], os.environ.get("BYOK_PROVIDER_TYPE", "openai"))

    # ProviderConfig routes the session through a custom endpoint instead of the GitHub
    # Copilot backend. `wire_api="completions"` is the broadly compatible choice; use
    # "responses" for providers that support the OpenAI Responses API.
    provider: ProviderConfig = {
        "type": provider_type,
        "base_url": os.environ["BYOK_BASE_URL"],
        "api_key": os.environ["BYOK_API_KEY"],
        "wire_api": "completions",
        "model_id": model_id,
    }

    # BYOK requires the model to also be set at the session level.
    agent: GitHubCopilotAgent[GitHubCopilotOptions] = GitHubCopilotAgent(
        instructions="You are a helpful assistant.",
        default_options=GitHubCopilotOptions(model=model_id, provider=provider),
    )

    async with agent:
        query = "What are the benefits of using your own API keys with an agent framework?"
        print(f"User: {query}")
        result = await agent.run(query)
        print(f"\nAgent: {result}\n")

Funkcje agenta

Dostawcy kontekstu

Język Python GitHubCopilotAgent obsługuje również język context_providers=[...]. Dostawcy są uruchamiani przed i po każdym wywołaniu, więc wiadomości i instrukcje dodane przez dostawcę są uwzględniane w monitach Copilota, a dostawcy historii mogą obserwować ostateczną odpowiedź.

from agent_framework import InMemoryHistoryProvider

agent = GitHubCopilotAgent(
    instructions="You are a helpful coding assistant.",
    context_providers=[InMemoryHistoryProvider()],
)

Możesz połączyć wbudowanych dostawców historii z niestandardowymi dostawcami kontekstu. Aby uzyskać informacje o wzorcach implementacji, zobacz Dostawcy kontekstu.

Narzędzia funkcji

Wyposażyć agenta w funkcje niestandardowe:

from typing import Annotated
from pydantic import Field

def get_weather(
    location: Annotated[str, Field(description="The location to get the weather for.")],
) -> str:
    """Get the weather for a given location."""
    return f"The weather in {location} is sunny with a high of 25C."

async def tools_example():
    agent = GitHubCopilotAgent(
        instructions="You are a helpful weather agent.",
        tools=[get_weather],
    )

    async with agent:
        result = await agent.run("What's the weather like in Seattle?")
        print(result)

Odpowiedzi w strumieniowaniu

Uzyskuj odpowiedzi w miarę ich generowania w celu lepszego doświadczenia użytkownika.

async def streaming_example():
    agent = GitHubCopilotAgent(
        instructions="You are a helpful assistant.",
    )

    async with agent:
        print("Agent: ", end="", flush=True)
        async for chunk in agent.run("Tell me a short story.", stream=True):
            if chunk.text:
                print(chunk.text, end="", flush=True)
        print()

Zarządzanie wątkami

Zachowaj kontekst konwersacji w wielu interakcjach:

async def thread_example():
    agent = GitHubCopilotAgent(
        instructions="You are a helpful assistant.",
    )

    async with agent:
        session = agent.create_session()

        # First interaction
        result1 = await agent.run("My name is Alice.", session=session)
        print(f"Agent: {result1}")

        # Second interaction - agent remembers the context
        result2 = await agent.run("What's my name?", session=session)
        print(f"Agent: {result2}")  # Should remember "Alice"

Permissions

Domyślnie agent nie może wykonywać poleceń powłoki, odczytywać/zapisywać plików ani pobierać URL-i. Aby włączyć te możliwości, podaj procedurę obsługi uprawnień:

import asyncio

from copilot.generated.rpc import PermissionDecisionDeniedInteractivelyByUser
from copilot.session import PermissionHandler, PermissionRequestResult
from copilot.session_events import PermissionRequest


async def prompt_permission(
    request: PermissionRequest, context: dict[str, str]
) -> PermissionRequestResult:
    print(f"\n[Permission Request: {request.kind}]")
    response = (await asyncio.to_thread(input, "Approve? (y/n): ")).strip().lower()
    if response in ("y", "yes"):
        return PermissionHandler.approve_all(request, context)
    return PermissionDecisionDeniedInteractivelyByUser()

async def permissions_example():
    agent = GitHubCopilotAgent(
        instructions="You are a helpful assistant that can execute shell commands.",
        default_options={
            "on_permission_request": prompt_permission,
        },
    )

    async with agent:
        result = await agent.run("List the Python files in the current directory")
        print(result)

W przypadku zaufanych środowisk, w których wszystkie zgody powinny być automatycznie akceptowane, użyj wbudowanego PermissionHandler.approve_all:

from copilot.session import PermissionHandler

agent = GitHubCopilotAgent(
    default_options={
        "on_permission_request": PermissionHandler.approve_all,
    },
)

Moduły obsługi uprawnień obsługują zarówno synchroniczne, jak i asynchroniczne wywołania zwrotne. Użyj polecenia asyncio.to_thread dla interakcyjnych monitów w programach obsługi asynchronicznych, aby uniknąć blokowania pętli zdarzeń.

Zatwierdzanie narzędzi

Ponieważ to pakiet GitHub Copilot SDK obsługuje pętlę wywołań narzędzi, zatwierdzanie niestandardowych narzędzi funkcyjnych jest realizowane za pomocą natywnego hooka przed wykonaniem w SDK, a nie standardowego mechanizmu zatwierdzania typu round-trip w Agent Framework. Gdy zarejestrujesz narzędzie zadeklarowane za pomocą approval_mode="always_require" i nie podasz własnej funkcji on_pre_tool_use hook, agent instaluje domyślną funkcję hook, która zwraca "ask" dla tego narzędzia i przekazuje tę decyzję do modułu obsługi on_permission_request:

from agent_framework import tool
from agent_framework.github import GitHubCopilotAgent, GitHubCopilotOptions
from copilot.session import PermissionHandler


@tool(approval_mode="always_require")
def delete_file(path: str) -> str:
    """Delete a file."""
    return f"Deleted {path}."


agent = GitHubCopilotAgent(
    tools=[delete_file],
    # The "ask" decision is routed here; approve or deny the call.
    default_options=GitHubCopilotOptions(on_permission_request=PermissionHandler.approve_all),
)

Serwery MCP

Nawiąż połączenie z lokalnymi (stdio) lub zdalnymi serwerami MCP (HTTP), aby uzyskać rozszerzone możliwości:

from copilot.session import MCPServerConfig, PermissionHandler

async def mcp_example():
    mcp_servers: dict[str, MCPServerConfig] = {
        # Local stdio server
        "filesystem": {
            "type": "stdio",
            "command": "npx",
            "args": ["-y", "@modelcontextprotocol/server-filesystem", "."],
            "tools": ["*"],
        },
        # Remote HTTP server
        "microsoft-learn": {
            "type": "http",
            "url": "https://learn.microsoft.com/api/mcp",
            "tools": ["*"],
        },
    }

    agent = GitHubCopilotAgent(
        instructions="You are a helpful assistant with access to the filesystem and Microsoft Learn.",
        default_options={
            "on_permission_request": PermissionHandler.approve_all,
            "mcp_servers": mcp_servers,
        },
    )

    async with agent:
        result = await agent.run("Search Microsoft Learn for 'Azure Functions' and summarize the top result")
        print(result)

Observability

GitHubCopilotAgent ma wbudowane śledzenie OpenTelemetry. Wywołaj configure_otel_providers() raz podczas uruchamiania, aby włączyć zakresy, metryki i dzienniki dla każdego przebiegu:

from agent_framework.observability import configure_otel_providers
from agent_framework.github import GitHubCopilotAgent

configure_otel_providers(enable_console_exporters=True)

async with GitHubCopilotAgent() as agent:
    response = await agent.run("Hello!")

Jeśli potrzebujesz podstawowego agenta bez warstwy telemetrii (na przykład do jego opakowania w niestandardowy), zaimportuj RawGitHubCopilotAgent z agent_framework.github.

Aby zapoznać się z eksporterami OTLP i bogatszymi przykładami, zapoznaj się z przykładami dotyczącymi możliwości obserwacyjnych.

Tools

Korzystanie z agenta

Agent jest standardowy BaseAgent i obsługuje wszystkie standardowe operacje agenta.

Aby uzyskać więcej informacji na temat uruchamiania agentów i interakcji z nimi, zobacz samouczki wprowadzające do agenta.

Wprowadzenie

Zainstaluj moduł Microsoft Agent Framework Go i zestaw SDK GitHub Copilot dla języka Go. Zestaw SDK języka Go platformy Agent wymaga języka Go w wersji 1.25 lub nowszej.

go get github.com/microsoft/agent-framework-go github.com/github/copilot-sdk/go

Tworzenie agenta Copilot w usłudze GitHub

Utwórz i uruchom element copilot.Client, a następnie przekaż go do copilotprovider.NewAgent.

import (
    "context"
    "fmt"

    copilot "github.com/github/copilot-sdk/go"
    "github.com/microsoft/agent-framework-go/provider/copilotprovider"
)

ctx := context.Background()

copilotClient := copilot.NewClient(nil)
if err := copilotClient.Start(ctx); err != nil {
    panic(err)
}
defer func() { _ = copilotClient.Stop() }()

copilotAgent := copilotprovider.NewAgent(
    copilotClient,
    copilotprovider.AgentConfig{
        Instructions: "You are a helpful assistant.",
    },
)

response, err := copilotAgent.RunText(ctx, "What is Microsoft Agent Framework?").Collect()
if err != nil {
    panic(err)
}
fmt.Println(response)

Za pomocą narzędzi i instrukcji

Podczas tworzenia agenta można udostępnić narzędzia funkcji i instrukcje niestandardowe:

import (
    "context"
    "fmt"

    copilot "github.com/github/copilot-sdk/go"
    "github.com/microsoft/agent-framework-go/agent"
    "github.com/microsoft/agent-framework-go/provider/copilotprovider"
    "github.com/microsoft/agent-framework-go/tool"
    "github.com/microsoft/agent-framework-go/tool/functool"
)

weatherTool := functool.MustNew(
    functool.Config{
        Name:        "GetWeather",
        Description: "Get the weather for a given location.",
    },
    func(_ context.Context, location string) (string, error) {
        return fmt.Sprintf("The weather in %s is sunny with a high of 25C.", location), nil
    },
)

copilotAgent := copilotprovider.NewAgent(
    copilotClient,
    copilotprovider.AgentConfig{
        Instructions: "You are a helpful weather agent.",
        Config: agent.Config{
            Tools: []tool.Tool{weatherTool},
        },
    },
)

response, err := copilotAgent.RunText(ctx, "What's the weather like in Seattle?").Collect()
if err != nil {
    panic(err)
}
fmt.Println(response)

Funkcje agenta

Odpowiedzi w strumieniowaniu

Pobierz odpowiedzi w miarę ich generowania:

for update, err := range copilotAgent.RunText(ctx, "Tell me a short story.", agent.Stream(true)) {
    if err != nil {
        panic(err)
    }
    fmt.Print(update)
}

fmt.Println()

Zarządzanie sesjami

Zachowaj kontekst konwersacji w wielu interakcjach przy użyciu sesji:

session, err := copilotAgent.CreateSession(ctx)
if err != nil {
    panic(err)
}

// First turn
response, err := copilotAgent.RunText(ctx, "My name is Alice.", agent.WithSession(session)).Collect()
if err != nil {
    panic(err)
}
fmt.Println(response)

// Second turn - the agent remembers the context
response, err = copilotAgent.RunText(ctx, "What is my name?", agent.WithSession(session)).Collect()
if err != nil {
    panic(err)
}
fmt.Println(response)

Permissions

Domyślnie agent nie może wykonywać poleceń powłoki, odczytywać/zapisywać plików ani pobierać URL-i. Aby włączyć te możliwości, podaj procedurę obsługi uprawnień za pomocą polecenia copilot.SessionConfig:

import (
    "bufio"
    "fmt"
    "os"
    "strings"

    copilot "github.com/github/copilot-sdk/go"
    "github.com/github/copilot-sdk/go/rpc"
    "github.com/microsoft/agent-framework-go/provider/copilotprovider"
)

func promptPermission(request copilot.PermissionRequest, _ copilot.PermissionInvocation) (rpc.PermissionDecision, error) {
    fmt.Printf("\n[Permission Request: %s]\n", request.Kind())
    fmt.Print("Approve? (y/n): ")

    input, _ := bufio.NewReader(os.Stdin).ReadString('\n')
    input = strings.TrimSpace(strings.ToUpper(input))
    if input == "Y" || input == "YES" {
        return &rpc.PermissionDecisionApproveOnce{}, nil
    }
    return &rpc.PermissionDecisionReject{}, nil
}

copilotAgent := copilotprovider.NewAgent(
    copilotClient,
    copilotprovider.AgentConfig{
        SessionConfig: &copilot.SessionConfig{
            OnPermissionRequest: promptPermission,
        },
    },
)

response, err := copilotAgent.RunText(ctx, "List all files in the current directory").Collect()
if err != nil {
    panic(err)
}
fmt.Println(response)

Serwery MCP

Nawiąż połączenie z lokalnymi (stdio) lub zdalnymi serwerami MCP (HTTP), aby uzyskać rozszerzone możliwości:

import (
    copilot "github.com/github/copilot-sdk/go"
    "github.com/microsoft/agent-framework-go/provider/copilotprovider"
)

mcpServers := map[string]copilot.MCPServerConfig{
    // Local stdio server
    "filesystem": copilot.MCPStdioServerConfig{
        Command: "npx",
        Args:    []string{"-y", "@modelcontextprotocol/server-filesystem", "."},
        Tools:   []string{"*"},
    },
    // Remote HTTP server
    "microsoft-learn": copilot.MCPHTTPServerConfig{
        URL:   "https://learn.microsoft.com/api/mcp",
        Tools: []string{"*"},
    },
}

copilotAgent := copilotprovider.NewAgent(
    copilotClient,
    copilotprovider.AgentConfig{
        Instructions: "You are a helpful assistant with access to the filesystem and Microsoft Learn.",
        SessionConfig: &copilot.SessionConfig{
            OnPermissionRequest: promptPermission,
            MCPServers:          mcpServers,
        },
    },
)

response, err := copilotAgent.RunText(ctx, "Search Microsoft Learn for 'Azure Functions' and summarize the top result").Collect()
if err != nil {
    panic(err)
}
fmt.Println(response)

Tools

Korzystanie z agenta

Agent jest standardowy *agent.Agent i obsługuje wszystkie standardowe operacje agenta.

Aby uzyskać więcej informacji na temat uruchamiania agentów i interakcji z nimi, zobacz samouczki wprowadzające do agenta.