GitHub Copilot

A Microsoft Agent Framework támogatja a GitHub Copilot SDK-t háttérként használó ügynökök létrehozását. A GitHub Copilot-ügynökök hatékony kódolás-orientált AI-képességekhez biztosítanak hozzáférést, beleértve a rendszerhéjparancsok végrehajtását, a fájlműveleteket, az URL-beolvasást és a Model Context Protocol (MCP) kiszolgálóintegrációját.

Important

GitHub Copilot ügynökök hitelesített GitHub Copilot futtatókörnyezetet igényelnek. Egyes SDK-k telepített parancssori felületet használnak, míg a Go SDK alapértelmezés szerint a csomagban lévő futtatókörnyezetet használja. A biztonság érdekében ajánlott rendszerhéj- vagy fájlengedélyekkel rendelkező ügynököket futtatni egy tárolóalapú környezetben (Docker/Dev Container).

Első lépések

Adja hozzá a szükséges NuGet-csomagokat a projekthez.

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

GitHub Copilot-ügynök létrehozása

Első lépésként hozzon létre egy CopilotClient elemet, és indítsa el. Ezután a AsAIAgent bővítménymetódus használatával hozzon létre egy ügynököt.

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

Eszközökkel és útmutatásokkal

Az ügynök létrehozásakor függvényeszközöket és egyéni utasításokat is megadhat:

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

Ügynökfunkciók

Adatfolyam válaszok

A válaszok azonnali fogadása, amint létrejönnek.

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

Munkamenet-kezelés

A beszélgetési környezet fenntartása több interakcióban munkamenetek használatával:

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

Alapértelmezés szerint az ügynök nem tud rendszerhéjparancsokat végrehajtani, fájlokat olvasni vagy írni, illetve URL-címeket beolvasni. A képességek engedélyezéséhez adjon meg egy engedélykezelőt a következő módon 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"));

Eszköz jóváhagyása

Mivel az eszközhívási ciklust a GitHub Copilot SDK kezeli, az egyéni függvényalapú eszközök jóváhagyását az SDK natív, végrehajtás előtti beakasztási pontja érvényesíti, nem pedig az Agent Framework szokásos jóváhagyási oda-vissza folyamata. Amikor egy ApprovalRequiredAIFunction-be csomagolt eszközt regisztrál, az ügynök telepít egy alapértelmezett OnPreToolUse hookot, amely az adott eszközhöz a "ask" értéket adja vissza, és a döntést a OnPermissionRequest kezelőnek továbbítja:

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

Ha a(z) SessionConfig.Hooks használatával saját OnPreToolUse hookot ad meg, az elsőbbséget élvez, és az ügynök nem telepíti az alapértelmezett jóváhagyási hookot. Ezután Ön teljes mértékben felelős az Ön által regisztrált bármely ApprovalRequiredAIFunction jóváhagyásának érvényesítéséért (például egy "deny" vagy "ask" döntés visszaadásával). Az ügynök figyelmeztetést naplóz, amely név szerint megjelöl minden jóváhagyást igénylő eszközt, amelyet a hooknak kezelnie kell.

MCP-kiszolgálók

Csatlakozzon helyi (stdio) vagy távoli (HTTP) MCP-kiszolgálókhoz a kiterjesztett képességek érdekében:

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

A teljes futtatható példákért tekintse meg a .NET-mintákat .

Tools

Eszköz	Status	Notes
Funktionális eszközök	✅	Standard AIFunction példányok.
Eszköz jóváhagyása	✅	A keretrendszer függvény-invokáló csevegőügyfele biztosítja; bármilyen függvényeszköz-hívással működik.
Kódértelmező	❌	Nem Copilot parancssori felületi funkció.
Fájlkeresés	❌	Nem Copilot parancssori felületi funkció.
Webes keresés	❌	Nem érhető el hosztolt eszközként.
Rendszerhéj / fájlrendszer / URL-beolvasás	✅	A Copilot CLI futtatókörnyezetébe van beépítve, és az Ön által megadott Permissions kezelő szabályozza.
Üzemeltetett MCP-eszközök	✅	SessionConfig.McpServers segítségével konfigurált távoli (HTTP-) MCP-kiszolgálók. Lásd: MCP-kiszolgálók.
Helyi MCP-eszközök	✅	SessionConfig.McpServers használatával konfigurált helyi (stdio) MCP-kiszolgálók Lásd: MCP-kiszolgálók.

Az ügynök használata

Az ügynök egy standard AIAgent és támogat minden szabványos AIAgent műveletet.

Az ügynökök futtatásával és használatával kapcsolatos további információkért tekintse meg az ügynök első lépéseket ismertető oktatóanyagait.

Prerequisites

Telepítse a Microsoft Agent Framework GitHub Copilot-csomagot.

pip install agent-framework-github-copilot

Configuration

Az ügynök opcionálisan a következő környezeti változók használatával konfigurálható:

Variable	Leírás
GITHUB_COPILOT_CLI_PATH	A Copilot CLI végrehajtható elérési útja
GITHUB_COPILOT_MODEL	Használandó modell (pl. gpt-5, claude-sonnet-4)
GITHUB_COPILOT_TIMEOUT	Kérelem időtúllépés ideje másodpercben
GITHUB_COPILOT_LOG_LEVEL	CLI-naplószint
GITHUB_COPILOT_BASE_DIRECTORY	A CLI-munkamenet állapotához és konfigurációjához tartozó könyvtár (alapértelmezés szerint: ~/.copilot)

Első lépések

Importálja a szükséges osztályokat az Agent Frameworkből:

import asyncio
from agent_framework.github import GitHubCopilotAgent, GitHubCopilotOptions

GitHub Copilot-ügynök létrehozása

Alapszintű ügynök létrehozás

GitHub Copilot-ügynök létrehozásának legegyszerűbb módja:

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)

Explicit konfigurációval

Az default_options alkalmazásával explicit konfigurációt adhat meg.

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 (és futtatásonként options) továbbít minden olyan paramétert, amelyet a Copilot SDK create_session elfogad — például reasoning_effort, context_tier, enable_citations, provider (saját kulcs használata) vagy skill_directories — nem csak az itt felsorolt kulcsokat. Az ismeretlen paraméternevek egy TypeError kiváltását eredményezik, így az elírásokat a rendszer nem hagyja figyelmen kívül csendben, hanem észleli őket.

Munkaterületi fájlhookok vezérlése

Alapértelmezés szerint GitHubCopilotAgent nem tölt be fájlhookokat a munkakönyvtár mappájából .github/hooks/ . Csak akkor engedélyezze, ha megbízik a munkakönyvtárban, és azt szeretné, hogy a hookok befolyásolják a munkamenetet:

from agent_framework.github import GitHubCopilotAgent, GitHubCopilotOptions
async def opt_in_to_file_hooks() -> None:
    """2. Opt in for a working directory whose hooks you trust."""
    print("=== 2. Opted in: file hooks from the working directory are loaded ===\n")

    agent: GitHubCopilotAgent[GitHubCopilotOptions] = GitHubCopilotAgent(
        instructions="You are a helpful assistant.",
        default_options=GitHubCopilotOptions(enable_file_hooks=True),
    )

    async with agent:
        result = await agent.run("In one sentence, what can you help me with?")
        print(f"Agent: {result}\n")

Warning

A fájlhookok parancsokat futtatnak az alkalmazást futtató felhasználóként. Ezeket nem a on_permission_request vagy más eszközjóváhagyási visszahívások szabályozzák.

Ha a munkakönyvtár hookokat definiál, és kihagyja a(z) enable_file_hooks elemet, az ügynök alapértelmezés szerint False értékre állítja, és a agent_framework.github_copilot naplózóval egyszer figyelmeztetést naplóz. A(z) enable_file_hooks=False explicit beállítása letiltja a hookokat anélkül, hogy ez a figyelmeztetés megjelenne.

Saját kulcs használata (BYOK)

A Copilot SDK BYOK-támogatásával a modellkéréseket saját OpenAI, Azure OpenAI, Anthropic vagy OpenAI-kompatibilis végponton keresztül irányíthatja a GitHub Copilot háttérrendszer helyett. Adjon át egy ProviderConfig-t a(z) GitHubCopilotOptions(provider=...) használatával, és állítsa be ugyanazt a modellazonosítót mind a szolgáltató konfigurációjában, mind a munkamenetszintű model beállításban is.

A futtatható minta a következő környezeti változókat használja:

Variable	Leírás
BYOK_PROVIDER_TYPE	Szolgáltató típusa: openai, azurevagy anthropic. Alapértelmezett érték: openai.
BYOK_BASE_URL	A szolgáltató végpontjának alap URL-címe.
BYOK_API_KEY	Statikus API-kulcs a szolgáltatói végponthoz.
BYOK_MODEL_ID	Kérendő modellazonosító. Alapértelmezett érték: gpt-4o.

A minta statikus API-kulcsot használ. A hitelesítő adatok rotálásához adja meg a(z) ProviderConfig elemen található kísérleti bearer_token_provider mezőt olyan szinkron vagy aszinkron visszahívásként, amely tokent ad vissza. A Copilot SDK minden szolgáltatói kéréshez meghívja a visszahívási függvényt, és ez a függvény felel a tokenek lekéréséért, gyorsítótárazásáért és frissítéséért. A bearertoken-szolgáltató elsőbbséget élvez a(z) api_key vagy bearer_token elemmel szemben, ha azok is be vannak állítva.

Warning

A statikus API-kulcsokat és tokeneket ne tárolja a forráskezelőben. Betöltheti őket környezeti változókból vagy titkos tárolókból. Az Ön szolgáltatója, nem a GitHub, követi nyomon a használatot és a számlázást.

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

Ügynökfunkciók

Kontextusszolgáltatók

A Python GitHubCopilotAgent is támogatja context_providers=[...]a . A szolgáltatók minden egyes meghívás előtt és után futnak, így a szolgáltatók által hozzáadott üzenetek és utasítások szerepelnek a Copilot parancssorában, és az előzményekkel foglalkozó szolgáltatók megfigyelhetik a végső választ.

from agent_framework import InMemoryHistoryProvider

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

A beépített előzményszolgáltatókat egyéni környezetszolgáltatókkal kombinálhatja. A megvalósítási mintákért tekintse meg a környezetszolgáltatókat.

Függvényeszközök

Ügynökét személyre szabott függvényekkel lássa el:

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)

Adatfolyam válaszok

A jobb felhasználói élmény érdekében a generált válaszok lekérése:

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

Szálkezelés

A beszélgetési környezet fenntartása több interakcióban:

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

Alapértelmezés szerint az ügynök nem tud rendszerhéjparancsokat végrehajtani, fájlokat olvasni vagy írni, illetve URL-címeket beolvasni. A képességek engedélyezéséhez adjon meg egy engedélykezelőt:

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)

Olyan megbízható környezetek esetén, ahol az összes engedélyt automatikusan jóvá kell hagyni, használja a beépített PermissionHandler.approve_all:

from copilot.session import PermissionHandler

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

Az engedélykezelők támogatják a szinkronizálást és az aszinkron visszahívásokat is. Használja a(z) asyncio.to_thread elemet interaktív promptokhoz az aszinkron kezelőkben, hogy elkerülje az eseményhurok blokkolását.

Eszköz jóváhagyása

Mivel az eszközhívási ciklust a GitHub Copilot SDK kezeli, az egyéni függvényalapú eszközök jóváhagyását az SDK natív, végrehajtás előtti beakasztási pontja érvényesíti, nem pedig az Agent Framework szokásos jóváhagyási oda-vissza folyamata. Amikor regisztrál egy, a(z) approval_mode="always_require" segítségével deklarált eszközt, és nem adja meg a saját on_pre_tool_use hookját, az ügynök beállít egy alapértelmezett hookot, amely "ask" értéket ad vissza az adott eszközhöz, és a döntést a on_permission_request kezelőjének továbbítja:

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

Ha saját on_pre_tool_use hookot ad meg, az elsőbbséget élvez, és az ügynök nem telepíti az alapértelmezett jóváhagyási hookot. Ezután teljes mértékben Ön felelős a jóváhagyás kényszerítéséért bármely approval_mode="always_require" eszköz esetében (például egy "deny" vagy "ask" egy határozat visszaküldésével). Az ügynök figyelmeztetést naplóz, amely név szerint megjelöl minden jóváhagyást igénylő eszközt, amelyet a hooknak kezelnie kell. Az alapértelmezett, mindent tiltó engedélykezelő esetén egy always_require eszköz le van tiltva, hacsak nem köt be egy jóváhagyó on_permission_request elemet.

MCP-kiszolgálók

Csatlakozzon helyi (stdio) vagy távoli (HTTP) MCP-kiszolgálókhoz a kiterjesztett képességek érdekében:

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 Beépített OpenTelemetria-nyomkövetéssel rendelkezik. Hívás configure_otel_providers() indításakor, hogy minden futtatáshoz engedélyezze a spanokat, a metrikákat és a naplókat:

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

Ha az alapul szolgáló ügynökre van szüksége a telemetriai réteg nélkül (például hogy egyéni ügynökbe szeretné becsomagolni), importálja a RawGitHubCopilotAgent-t a agent_framework.github-ből.

Az OTLP-exportőrök és a gazdagabb példák esetében lásd a megfigyelhetőségi mintákat.

Tools

Eszköz	Status	Notes
Funktionális eszközök	✅	Szabványos Python-hívható objektumok vagy @ai_function.
Eszköz jóváhagyása	✅	A keretrendszer függvény-invokáló csevegőügyfele biztosítja; bármilyen függvényeszköz-hívással működik.
Kódértelmező	❌	Nem Copilot parancssori felületi funkció.
Fájlkeresés	❌	Nem Copilot parancssori felületi funkció.
Webes keresés	❌	Nem érhető el hosztolt eszközként.
Rendszerhéj / fájlrendszer / URL-beolvasás	✅	A Copilot CLI futtatókörnyezetébe van beépítve, és az Ön által megadott Permissions kezelő szabályozza.
Üzemeltetett MCP-eszközök	✅	default_options["mcp_servers"] segítségével konfigurált távoli (HTTP-) MCP-kiszolgálók. Lásd: MCP-kiszolgálók.
Helyi MCP-eszközök	✅	default_options["mcp_servers"] használatával konfigurált helyi (stdio) MCP-kiszolgálók Lásd: MCP-kiszolgálók.

Az ügynök használata

Az ügynök egy szabványos BaseAgent, és támogatja az összes szabványos ügynökműveletet.

Az ügynökök futtatásával és használatával kapcsolatos további információkért tekintse meg az ügynök első lépéseket ismertető oktatóanyagait.

Első lépések

Telepítse az Microsoft Agent Framework Go modult és a go-hoz készült GitHub Copilot SDK-t. Az Agent Framework Go SDK használatához Go 1.25-ös vagy újabb verzió szükséges.

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

GitHub Copilot-ügynök létrehozása

Hozzon létre és indítson el egy copilot.Client elemet, majd adja át a copilotprovider.NewAgent-nek.

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)

Eszközökkel és útmutatásokkal

Az ügynök létrehozásakor függvényeszközöket és egyéni utasításokat is megadhat:

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)

Ügynökfunkciók

Adatfolyam válaszok

A válaszok azonnali fogadása, amint létrejönnek.

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

Munkamenet-kezelés

A beszélgetési környezet fenntartása több interakcióban munkamenetek használatával:

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

Alapértelmezés szerint az ügynök nem tud rendszerhéjparancsokat végrehajtani, fájlokat olvasni vagy írni, illetve URL-címeket beolvasni. A képességek engedélyezéséhez adjon meg egy engedélykezelőt a következő módon 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)

MCP-kiszolgálók

Csatlakozzon helyi (stdio) vagy távoli (HTTP) MCP-kiszolgálókhoz a kiterjesztett képességek érdekében:

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

A teljes futtatható példáért tekintse meg a Go GitHub Copilot-mintát.

Tools

Eszköz	Status	Notes
Funktionális eszközök	✅	Standard Go-példányok tool.Tool , beleértve a functool függvényeket is.
Eszköz jóváhagyása	✅	A függvényeszközök használhatják a szokásos Go eszközjóváhagyási támogatást; Copilot futásidejű engedélyeket a SessionConfig.OnPermissionRequestrendszer kezeli.
Kódértelmező	❌	Nem Copilot parancssori felületi funkció.
Fájlkeresés	❌	Nem Copilot parancssori felületi funkció.
Webes keresés	❌	Nem érhető el hosztolt eszközként.
Rendszerhéj / fájlrendszer / URL-beolvasás	✅	A Copilot CLI futtatókörnyezetébe van beépítve, és az Ön által megadott Permissions kezelő szabályozza.
Üzemeltetett MCP-eszközök	✅	copilot.SessionConfig.MCPServers segítségével konfigurált távoli (HTTP-) MCP-kiszolgálók. Lásd: MCP-kiszolgálók.
Helyi MCP-eszközök	✅	copilot.SessionConfig.MCPServers használatával konfigurált helyi (stdio) MCP-kiszolgálók Lásd: MCP-kiszolgálók.

Az ügynök használata

Az ügynök egy szabványos *agent.Agent, és támogatja az összes szabványos ügynökműveletet.

Az ügynökök futtatásával és használatával kapcsolatos további információkért tekintse meg az ügynök első lépéseket ismertető oktatóanyagait.

Következő lépések

Copilot Studio