GitHub Copilot

Program Microsoft Agent Framework obsługuje tworzenie agentów korzystających z zestawu SDK narzędzia GitHub Copilot jako zaplecza. Agenci GitHub Copilot zapewniają dostęp do potężnych możliwości sztucznej inteligencji zorientowanej na kodowanie, w tym wykonywanie poleceń powłoki, operacje na plikach, pobieranie adresów URL oraz integrację z serwerem PROTOKOŁU MCP (Model Context Protocol).

Ważna

Agenty GitHub Copilot wymagają uwierzytelnionego środowiska uruchomieniowego GitHub Copilot. Niektóre zestawy SDK używają zainstalowanego interfejsu wiersza polecenia, a zestaw SDK języka Go domyślnie używa dołączonego środowiska uruchomieniowego. W przypadku zabezpieczeń zaleca się uruchamianie agentów z uprawnieniami powłoki lub plików w środowisku konteneryzowanym (Docker/Dev Container).

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 jest właścicielem pętli wywoływania narzędzi, zatwierdzenie niestandardowych narzędzi funkcji jest wymuszane za pomocą natywnego elementu zaczepienia przed wykonaniem zestawu SDK, a nie standardowej rundy zatwierdzania struktury agenta. Po zarejestrowaniu narzędzia opakowanego w ApprovalRequiredAIFunctionprogramie agent instaluje domyślny OnPreToolUse punkt zaczepienia, który zwraca "ask" dla tego narzędzia i kieruje decyzję do OnPermissionRequest programu obsługi:

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

Warning

Jeśli podasz własny OnPreToolUse punkt zaczepienia za pośrednictwem metody SessionConfig.Hooks, ma pierwszeństwo, a agent nie instaluje domyślnego haka zatwierdzania. Użytkownik jest wówczas w pełni odpowiedzialny za wymuszanie zatwierdzenia dla każdej ApprovalRequiredAIFunction rejestracji (na przykład poprzez zwrócenie "deny" decyzji lub "ask" ). Agent rejestruje ostrzeżenie nazewnictwa dowolnego narzędzia wymaganego do zatwierdzenia, które musi obsłużyć hak.

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

Wskazówka

Zobacz przykłady .NET dla kompletnych, działających przykładów.

Tools

Narzędzie	Status	Notatki
Narzędzia funkcji	✅	Instancje w warstwie Standard AIFunction.
Zatwierdzanie narzędzi	✅	Zapewniane przez klienta czatu frameworka do wywoływania funkcji; działa z dowolnym wywołaniem narzędzia-funkcji.
Interpreter kodów	❌	To nie jest funkcja interfejsu wiersza polecenia Copilot.
Wyszukiwanie plików	❌	To nie jest funkcja interfejsu wiersza polecenia Copilot.
Wyszukiwanie w Sieci Web	❌	Niedostępne jako narzędzie hostowane.
Pobieranie powłoki/systemu plików/adresu URL	✅	Wbudowane w środowisko uruchomieniowe interfejsu wiersza polecenia Copilot i kontrolowane przez dostarczony moduł obsługi Permissions.
Hostowane narzędzia MCP	✅	Zdalne serwery MCP (HTTP) skonfigurowane za pośrednictwem programu SessionConfig.McpServers. Zobacz Serwery MCP.
Lokalne narzędzia MCP	✅	Lokalne (stdio) serwery MCP skonfigurowane za pośrednictwem programu SessionConfig.McpServers. Zobacz Serwery MCP.

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:

Zmienna	Description
GITHUB_COPILOT_CLI_PATH	Ścieżka do pliku wykonywalnego Copilot CLI
GITHUB_COPILOT_MODEL	Model do użycia (np. gpt-5, claude-sonnet-4)
GITHUB_COPILOT_TIMEOUT	Limit czasu żądania w sekundach
GITHUB_COPILOT_LOG_LEVEL	Poziom logów CLI
GITHUB_COPILOT_BASE_DIRECTORY	Katalog stanu sesji i konfiguracji CLI (domyślnie: ~/.copilot)

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)

Wskazówka

default_options(i na przebieg options) Przekazuje wszystkie parametry akceptowane przez zestawy SDK create_session Copilot — na przykład reasoning_effort, context_tier, enable_citations, provider (bring-your-own-key) lub skill_directories — nie tylko klucze pokazane tutaj. Nieznane nazwy parametrów zgłaszają wartość TypeError, więc literówki są przechwytywane, a nie dyskretnie ignorowane.

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

Obsługa byOK zestawu SDK Copilot umożliwia kierowanie żądań modelu za pośrednictwem własnego interfejsu OpenAI, Azure OpenAI, Anthropic lub punktu końcowego zgodnego z interfejsem OpenAI zamiast zaplecza GitHub Copilot. ProviderConfig GitHubCopilotOptions(provider=...)Przekaż element i ustaw ten sam identyfikator modelu zarówno w konfiguracji dostawcy, jak i opcji na poziomie model sesji.

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

Zmienna	Description
BYOK_PROVIDER_TYPE	Typ dostawcy: openai, azurelub anthropic. Wartość domyślna to openai.
BYOK_BASE_URL	Podstawowy adres URL punktu końcowego dostawcy.
BYOK_API_KEY	Statyczny klucz interfejsu API dla punktu końcowego dostawcy.
BYOK_MODEL_ID	Identyfikator modelu do żądania. Wartość domyślna to gpt-4o.

Warning

Funkcja BYOK używa poświadczeń statycznych i nie zapewnia automatycznego odświeżania tokenu. Zachowaj klucze interfejsu API poza kontrolą źródła i załaduj je ze zmiennych środowiskowych lub magazynu wpisów tajnych. Użycie i rozliczenia są śledzone przez dostawcę, a nie przez GitHub.

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ż zestaw SDK GitHub Copilot jest właścicielem pętli wywoływania narzędzi, zatwierdzenie niestandardowych narzędzi funkcji jest wymuszane za pomocą natywnego elementu zaczepienia przed wykonaniem zestawu SDK, a nie standardowej rundy zatwierdzania struktury agenta. Po zarejestrowaniu narzędzia zadeklarowanego approval_mode="always_require" za pomocą polecenia i nie podaniu własnego on_pre_tool_use haka agent instaluje domyślny punkt zaczepienia, który zwraca "ask" dla tego narzędzia i kieruje decyzję on_permission_request do programu obsługi:

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

Warning

Jeśli podasz własny on_pre_tool_use punkt zaczepienia, pierwszeństwo ma agent, a agent nie instaluje domyślnego haka zatwierdzania. Użytkownik jest wówczas w pełni odpowiedzialny za wymuszanie zatwierdzenia dla dowolnego approval_mode="always_require" narzędzia (na przykład przez zwrócenie "deny" decyzji lub "ask" ). Agent rejestruje ostrzeżenie nazewnictwa dowolnego narzędzia wymaganego do zatwierdzenia, które musi obsłużyć hak. W przypadku domyślnej procedury obsługi uprawnień odmów wszystkich narzędzie jest odrzucane, always_require chyba że podłączasz zatwierdzenie on_permission_request.

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

Narzędzie	Status	Notatki
Narzędzia funkcji	✅	Standardowe obiekty wywoływalne Pythona lub @ai_function.
Zatwierdzanie narzędzi	✅	Zapewniane przez klienta czatu frameworka do wywoływania funkcji; działa z dowolnym wywołaniem narzędzia-funkcji.
Interpreter kodów	❌	To nie jest funkcja interfejsu wiersza polecenia Copilot.
Wyszukiwanie plików	❌	To nie jest funkcja interfejsu wiersza polecenia Copilot.
Wyszukiwanie w Sieci Web	❌	Niedostępne jako narzędzie hostowane.
Pobieranie powłoki/systemu plików/adresu URL	✅	Wbudowane w środowisko uruchomieniowe Copilot CLI i kontrolowane przez dostarczony przez Ciebie program obsługi Permissions.
Hostowane narzędzia MCP	✅	Zdalne serwery MCP (HTTP) skonfigurowane za pośrednictwem programu default_options["mcp_servers"]. Zobacz Serwery MCP.
Lokalne narzędzia MCP	✅	Lokalne (stdio) serwery MCP skonfigurowane za pośrednictwem programu default_options["mcp_servers"]. Zobacz Serwery MCP.

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)

Wskazówka

Zobacz przykład GitHub Copilot dla języka Go, aby zapoznać się z kompletnym działającym przykładem.

Tools

Narzędzie	Status	Notatki
Narzędzia funkcji	✅	Standardowe instancje Go tool.Tool, w tym funkcje functool.
Zatwierdzanie narzędzi	✅	Narzędzia funkcji mogą korzystać ze standardowego mechanizmu zatwierdzania narzędzi Go; uprawnienia środowiska uruchomieniowego Copilot są obsługiwane przez SessionConfig.OnPermissionRequest.
Interpreter kodów	❌	To nie jest funkcja interfejsu wiersza polecenia Copilot.
Wyszukiwanie plików	❌	To nie jest funkcja interfejsu wiersza polecenia Copilot.
Wyszukiwanie w Sieci Web	❌	Niedostępne jako narzędzie hostowane.
Pobieranie powłoki/systemu plików/adresu URL	✅	Wbudowane w środowisko uruchomieniowe Copilot CLI i kontrolowane przez dostarczony przez Ciebie program obsługi Permissions.
Hostowane narzędzia MCP	✅	Zdalne serwery MCP (HTTP) skonfigurowane za pośrednictwem programu copilot.SessionConfig.MCPServers. Zobacz Serwery MCP.
Lokalne narzędzia MCP	✅	Lokalne (stdio) serwery MCP skonfigurowane za pośrednictwem programu copilot.SessionConfig.MCPServers. Zobacz Serwery MCP.

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.

Następne kroki

Copilot Studio