GitHub Copilot

Microsoft Agent Framework podporuje vytváření agentů, kteří jako svůj back-end používají sadu GitHub Copilot SDK . Agenti GitHub Copilot poskytují přístup k výkonným funkcím AI zaměřené na kódování, včetně spouštění příkazů prostředí, operací se soubory, načítání adres URL a integrace serveru MCP (Model Context Protocol).

Important

Agenti GitHub Copilot vyžadují ověřené běhové prostředí GitHub Copilot. Některé sady SDK používají nainstalované CLI, zatímco Go SDK ve výchozím nastavení používá přibalené běhové prostředí. Pro zabezpečení se doporučuje spouštět agenty s oprávněními pro shell nebo soubory v kontejnerizovaném prostředí (Docker/vývojový kontejner).

Začínáme

Přidejte do projektu požadované balíčky NuGet.

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

Vytvoření agenta GitHub Copilot

Jako první krok vytvořte CopilotClient a spusťte ho. Pak pomocí AsAIAgent metody rozšíření vytvořte 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?"));

S nástroji a pokyny

Při vytváření agenta můžete poskytnout nástroje funkcí a vlastní pokyny:

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

Funkce agenta

Odpovědi na streamování

Získejte odpovědi hned, jakmile jsou generovány:

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

Správa relací

Udržujte kontext konverzace napříč několika interakcemi pomocí relací:

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

Ve výchozím nastavení agent nemůže spouštět příkazy shellu, číst ani zapisovat soubory, ani načítat adresy URL. Pokud chcete tyto možnosti povolit, zadejte obslužnou rutinu oprávnění prostřednictvím 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"));

Schválení nástroje

Vzhledem k tomu, že sada GitHub Copilot SDK vlastní smyčku volání nástrojů, je schválení vlastních nástrojů funkcí vynuceno prostřednictvím nativního háku předběžného spuštění sady SDK místo standardní doby odezvy schválení rozhraní Agent Framework. Když zaregistrujete nástroj zabalený ApprovalRequiredAIFunctiondo , agent nainstaluje výchozí OnPreToolUse hák, který se vrátí "ask" pro tento nástroj, a směruje rozhodnutí na obslužnou OnPermissionRequest rutinu:

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

Pokud zadáte vlastní OnPreToolUse háček, SessionConfig.Hooksbude mít přednost a agent neinstaluje svůj výchozí schvalovací háček. Pak jste plně zodpovědní za vynucování schválení pro všechny ApprovalRequiredAIFunction , které zaregistrujete (například vrácením "deny" nebo "ask" rozhodnutím). Agent zaznamená upozornění na název libovolného nástroje potřebného ke schválení, který váš háček musí zpracovat.

Servery MCP

Připojte se k místním serverům (stdio) nebo vzdálenému serveru (HTTP) MCP pro rozšířené možnosti:

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

Tip

Kompletní příklady s možností spuštění najdete v ukázkách .NET.

Tools

nástroj	Stav	Poznámky
Funkční nástroje	✅	Standardní `AIFunction` instance.
Schválení nástroje	✅	Poskytováno chatovacím klientem rámce pro vyvolávání funkcí; funguje s libovolným voláním nástroje-funkce.
Interpretér kódu	❌	Nejde o funkci Copilot CLI.
Hledání souborů	❌	Nejde o funkci Copilot CLI.
Vyhledávání na webu	❌	Není dostupný jako hostovaný nástroj.
Shell / systém souborů / Načítání adres URL	✅	Vestavěné do modulu runtime rozhraní Copilot CLI a podmíněné obslužnou funkcí Permissions, kterou zadáte.
Hostované nástroje MCP	✅	Vzdálené servery (HTTP) MCP nakonfigurované prostřednictvím `SessionConfig.McpServers`. Vizte Servery MCP.
Místní nástroje MCP	✅	Místní (stdio) MCP servery nakonfigurované prostřednictvím `SessionConfig.McpServers`. Vizte Servery MCP.

Použití agenta

Agent AIAgent je standardní a podporuje všechny standardní AIAgent operace.

Další informace o tom, jak spouštět agenty a pracovat s nimi, najdete v úvodních kurzech agenta.

Předpoklady

Nainstalujte balíček GitHub Copilot v rozhraní Microsoft Agent Framework.

pip install agent-framework-github-copilot

Configuration

Agenta můžete volitelně nakonfigurovat pomocí následujících proměnných prostředí:

Proměnné	Description
`GITHUB_COPILOT_CLI_PATH`	Cesta ke spustitelnému souboru rozhraní příkazového řádku Copilot
`GITHUB_COPILOT_MODEL`	Model, který se má použít (např. `gpt-5`, `claude-sonnet-4`)
`GITHUB_COPILOT_TIMEOUT`	Časový limit požadavku v sekundách
`GITHUB_COPILOT_LOG_LEVEL`	Úroveň protokolu CLI
`GITHUB_COPILOT_BASE_DIRECTORY`	Adresář pro stav relace CLI a konfiguraci (výchozí hodnota je `~/.copilot`)

Začínáme

Import požadovaných tříd z rozhraní Agent Framework:

import asyncio
from agent_framework.github import GitHubCopilotAgent, GitHubCopilotOptions

Vytvoření agenta GitHub Copilot

Základní vytvoření agenta

Nejjednodušší způsob vytvoření 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)

S explicitní konfigurací

Explicitní konfiguraci můžete poskytnout prostřednictvím 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)

Tip

default_options(a po spuštěníoptions) předá všechny parametry přijaté Copilot SDK create_session , například context_tierreasoning_effort, , , enable_citationsprovider (přineste si vlastní klíč) nebo skill_directories – nejen klíče zobrazené zde. Neznámé názvy parametrů vyvolávají TypeErrorchybu, takže překlepy jsou zachyceny spíše než bezobslužně ignorovány.

Přineste si vlastní klíč (BYOK)

Pomocí podpory modelu BYOK sady Copilot SDK můžete směrovat požadavky na modely prostřednictvím vlastního koncového bodu OpenAI, Azure OpenAI, Anthropic nebo openAI kompatibilního s GitHub Copilot back-endem. ProviderConfig GitHubCopilotOptions(provider=...)Předání a nastavení stejného identifikátoru modelu v konfiguraci zprostředkovatele i možnosti na úrovni model relace.

Spustitelná ukázka používá tyto proměnné prostředí:

Proměnné	Description
`BYOK_PROVIDER_TYPE`	Typ poskytovatele: `openai`, `azure`nebo `anthropic`. Výchozí hodnota je `openai`.
`BYOK_BASE_URL`	Základní adresa URL koncového bodu poskytovatele
`BYOK_API_KEY`	Statický klíč rozhraní API pro koncový bod poskytovatele
`BYOK_MODEL_ID`	Identifikátor modelu, který se má vyžádat. Výchozí hodnota je `gpt-4o`.

Warning

BYOK používá statické přihlašovací údaje a neposkytuje automatickou aktualizaci tokenů. Udržujte klíče rozhraní API mimo správu zdrojového kódu a načtěte je z proměnných prostředí nebo úložiště tajných kódů. Využití a fakturace sleduje váš poskytovatel, nikoli 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")

Funkce agenta

Zprostředkovatelé kontextu

Python GitHubCopilotAgent také podporuje context_providers=[...]. Zprostředkovatelé běží před a po každém vyvolání, takže zprávy a pokyny přidané zprostředkovateli jsou zahrnuty do výzev Copilotu a poskytovatelé historie mohou sledovat konečnou odpověď.

from agent_framework import InMemoryHistoryProvider

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

Předdefinované zprostředkovatele historie můžete kombinovat s vlastními zprostředkovateli kontextu. Vzory implementace najdete v tématu Zprostředkovatelé kontextu.

Funkční nástroje

Vybavení agenta vlastními funkcemi:

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)

Odpovědi na streamování

Získejte odpovědi, protože se generují pro lepší uživatelské prostředí:

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

Správa vláken

Udržujte kontext konverzace napříč několika interakcemi:

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

Ve výchozím nastavení agent nemůže spouštět příkazy shellu, číst ani zapisovat soubory, ani načítat adresy URL. Pokud chcete povolit tyto možnosti, zadejte obslužnou rutinu oprávnění:

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)

V případě důvěryhodných prostředí, kde by měla být všechna oprávnění automaticky schválena, použijte předdefinované PermissionHandler.approve_all:

from copilot.session import PermissionHandler

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

Obslužné funkce oprávnění podporují synchronní i asynchronní funkce zpětného volání. Používejte asyncio.to_thread pro interaktivní dotazy v asynchronních obslužných rutinách, aby nedošlo k blokování smyčky událostí.

Schválení nástroje

Vzhledem k tomu, že sada GitHub Copilot SDK vlastní smyčku volání nástrojů, je schválení vlastních nástrojů funkcí vynuceno prostřednictvím nativního háku předběžného spuštění sady SDK místo standardní doby odezvy schválení rozhraní Agent Framework. Když zaregistrujete nástroj deklarovaný a approval_mode="always_require" nezadáte vlastní on_pre_tool_use háček, agent nainstaluje výchozí háček, který se vrátí "ask" pro tento nástroj, a směruje rozhodnutí do obslužné on_permission_request rutiny:

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

Pokud zadáte vlastní on_pre_tool_use háček, bude mít přednost a agent neinstaluje svůj výchozí schvalovací háček. Pak jste plně zodpovědní za vynucování schválení libovolného approval_mode="always_require" nástroje (například vrácením "deny" rozhodnutí)."ask" Agent zaznamená upozornění na název libovolného nástroje potřebného ke schválení, který váš háček musí zpracovat. U výchozí obslužné rutiny odepření všech oprávnění je nástroj odepřen, always_require pokud nezavoláte schválení on_permission_request.

Servery MCP

Připojte se k místním serverům (stdio) nebo vzdálenému serveru (HTTP) MCP pro rozšířené možnosti:

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 má integrované trasování OpenTelemetry. Voláním configure_otel_providers() jednou při spuštění povolíte rozsahy, metriky a protokoly pro každé spuštění:

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

Chcete-li použít základního agenta bez vrstvy telemetrie, například když chcete vytvořit vlastní obal, importujte RawGitHubCopilotAgent z agent_framework.github.

V případě exportérů OTLP a bohatších příkladů se podívejte na ukázky pozorovatelnosti.

Tools

nástroj	Stav	Poznámky
Funkční nástroje	✅	Standardní volatelné objekty Pythonu nebo `@ai_function`.
Schválení nástroje	✅	Poskytováno chatovacím klientem rámce pro vyvolávání funkcí; funguje s libovolným voláním nástroje-funkce.
Interpretér kódu	❌	Nejde o funkci Copilot CLI.
Hledání souborů	❌	Nejde o funkci Copilot CLI.
Vyhledávání na webu	❌	Není dostupný jako hostovaný nástroj.
Shell / systém souborů / Načítání adres URL	✅	Integrované do běhového prostředí Copilot CLI a řízené handlerem Permissions, který zadáte.
Hostované nástroje MCP	✅	Vzdálené servery (HTTP) MCP nakonfigurované prostřednictvím `default_options["mcp_servers"]`. Vizte Servery MCP.
Místní nástroje MCP	✅	Místní (stdio) MCP servery nakonfigurované prostřednictvím `default_options["mcp_servers"]`. Vizte Servery MCP.

Použití agenta

Agent je standardní BaseAgent a podporuje všechny standardní operace agentů.

Další informace o tom, jak spouštět agenty a pracovat s nimi, najdete v úvodních kurzech agenta.

Začínáme

Nainstalujte modul Microsoft Agent Framework Go a sadu GitHub Copilot SDK for Go. Sada SDK pro Go pro platformu Agent Framework vyžaduje Go 1.25 nebo novější.

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

Vytvoření agenta GitHub Copilot

Vytvořte a spusťte copilot.Client, pak ho předejte 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)

S nástroji a pokyny

Při vytváření agenta můžete poskytnout nástroje funkcí a vlastní pokyny:

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)

Funkce agenta

Odpovědi na streamování

Získejte odpovědi hned, jakmile jsou generovány:

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

Správa relací

Udržujte kontext konverzace napříč několika interakcemi pomocí relací:

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

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)

Servery MCP

Připojte se k místním serverům (stdio) nebo vzdálenému serveru (HTTP) MCP pro rozšířené možnosti:

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)

Tip

Podívejte se na ukázku GitHub Copilot pro Go, kde najdete kompletní spustitelný příklad.

Tools

nástroj	Stav	Poznámky
Funkční nástroje	✅	Instance Standard Go `tool.Tool` včetně funkcí `functool`.
Schválení nástroje	✅	Funkční nástroje mohou používat standardní podporu pro schvalování nástrojů v Go; oprávnění modulu runtime pro Copilot zpracovává `SessionConfig.OnPermissionRequest`.
Interpretér kódu	❌	Nejde o funkci Copilot CLI.
Hledání souborů	❌	Nejde o funkci Copilot CLI.
Vyhledávání na webu	❌	Není dostupný jako hostovaný nástroj.
Shell / systém souborů / Načítání adres URL	✅	Integrované do běhového prostředí Copilot CLI a řízené handlerem Permissions, který zadáte.
Hostované nástroje MCP	✅	Vzdálené servery (HTTP) MCP nakonfigurované prostřednictvím `copilot.SessionConfig.MCPServers`. Vizte Servery MCP.
Místní nástroje MCP	✅	Místní (stdio) MCP servery nakonfigurované prostřednictvím `copilot.SessionConfig.MCPServers`. Vizte Servery MCP.

Použití agenta

Agent je standardní *agent.Agent a podporuje všechny standardní operace agentů.

Další informace o tom, jak spouštět agenty a pracovat s nimi, najdete v úvodních kurzech agenta.

Další kroky

Copilot Studio

Váš názor

Byla tato stránka užitečná?

Last updated on 2026-08-13

GitHub Copilot

Začínáme

Vytvoření agenta GitHub Copilot

S nástroji a pokyny

Funkce agenta

Odpovědi na streamování

Správa relací

Permissions

Schválení nástroje

Servery MCP

Tools

Použití agenta

Předpoklady

Configuration

Začínáme

Vytvoření agenta GitHub Copilot

Základní vytvoření agenta

S explicitní konfigurací

Přineste si vlastní klíč (BYOK)

Funkce agenta

Zprostředkovatelé kontextu

Funkční nástroje

Odpovědi na streamování

Správa vláken

Permissions

Schválení nástroje

Servery MCP

Observability

Tools

Použití agenta

Začínáme

Vytvoření agenta GitHub Copilot

S nástroji a pokyny

Funkce agenta

Odpovědi na streamování

Správa relací

Permissions

Servery MCP

Tools

Použití agenta

Další kroky

Váš názor

Další materiály