GitHub Copilot

O Microsoft Agent Framework dá suporte à criação de agentes que usam o SDK do GitHub Copilot como back-end. Os agentes do GitHub Copilot fornecem acesso a funcionalidades avançadas de IA voltadas para codificação, incluindo execução de comandos shell, operações de arquivo, busca de URL e integração do servidor MCP (Protocolo de Contexto de Modelo).

Important

Os agentes do GitHub Copilot requerem um runtime autenticado do GitHub Copilot. Alguns SDKs usam uma CLI instalada, enquanto o SDK do Go usa o runtime empacotado por padrão. Para segurança, é recomendável executar agentes com permissões de shell ou arquivo em um ambiente em contêineres (Contêiner de Desenvolvimento/Docker).

Introdução

Adicione os pacotes NuGet necessários ao seu projeto.

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

Criar um Agente Copilot do GitHub

Como primeira etapa, crie um CopilotClient e inicie-o. Em seguida, use o AsAIAgent método de extensão para criar um agente.

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

Com ferramentas e instruções

Você pode fornecer ferramentas de função e instruções personalizadas ao criar o agente:

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

Funcionalidades do agente

Respostas de transmissão contínua

Obtenha respostas conforme elas são geradas:

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

Gerenciamento da sessão

Mantenha o contexto de conversa em várias interações usando sessões:

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

Por padrão, o agente não pode executar comandos de shell, arquivos de leitura/gravação ou buscar URLs. Para habilitar esses recursos, forneça um manipulador de permissões por meio de 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"));

Aprovação da ferramenta

Como o SDK do GitHub Copilot gerencia o loop de chamada de ferramentas, a aprovação para ferramentas de funções personalizadas é aplicada por meio do hook de pré-execução nativo do SDK, em vez do fluxo padrão de aprovação do Agent Framework. Quando você registra uma ferramenta encapsulada em ApprovalRequiredAIFunction, o agente instala um hook padrão OnPreToolUse que retorna "ask" para essa ferramenta e encaminha a decisão para o manipulador 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"));

Aviso

Se você fornecer seu próprio hook OnPreToolUse via SessionConfig.Hooks, ele terá precedência, e o agente não instalará seu hook de aprovação padrão. Você é, então, totalmente responsável por garantir a aprovação de qualquer ApprovalRequiredAIFunction que registrar (por exemplo, retornando uma decisão "deny" ou "ask"). O agente registra um aviso identificando qualquer ferramenta que exija aprovação e que o seu hook deva processar.

Servidores MCP

Conecte-se a servidores MCP locais (stdio) ou remotos (HTTP) para recursos estendidos:

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

Consulte os exemplos do .NET para obter exemplos executáveis completos.

Tools

Tool	Status	Notes
Ferramentas de Funções	✅	Instâncias AIFunction padrão.
Aprovação da ferramenta	✅	Fornecido pelo cliente de chat com invocação de funções da estrutura; funciona com qualquer chamada de ferramenta de função.
Interpretador de Código	❌	Não é um recurso do Copilot CLI.
Pesquisa de Arquivo	❌	Não é um recurso do Copilot CLI.
Pesquisa na Web	❌	Não está disponível como uma ferramenta hospedada.
Shell/sistema de arquivos/busca de URL	✅	Integrado ao runtime do Copilot CLI e controlado pelo manipulador Permissions que você fornece.
Ferramentas MCP hospedadas	✅	Servidores MCP remotos (HTTP) configurados por meio de SessionConfig.McpServers. Consulte servidores MCP.
Ferramentas MCP locais	✅	Servidores MCP locais (stdio) configurados por meio de SessionConfig.McpServers. Consulte servidores MCP.

Usando o agente

O agente é um AIAgent padrão e oferece suporte a todas as operações padrão AIAgent.

Para obter mais informações sobre como executar e interagir com agentes, consulte os tutoriais de introdução do Agente.

Prerequisites

Instale o pacote do GitHub Copilot do Microsoft Agent Framework.

pip install agent-framework-github-copilot

Configuration

O agente pode ser configurado opcionalmente usando as seguintes variáveis de ambiente:

Variable	Description
GITHUB_COPILOT_CLI_PATH	Caminho para o executável da CLI do Copilot
GITHUB_COPILOT_MODEL	Modelo a ser usado (por exemplo, gpt-5, claude-sonnet-4)
GITHUB_COPILOT_TIMEOUT	Tempo limite da solicitação em segundos
GITHUB_COPILOT_LOG_LEVEL	Nível de log da CLI
GITHUB_COPILOT_BASE_DIRECTORY	Diretório para o estado e a configuração da sessão da CLI (o padrão é ~/.copilot)

Introdução

Importe as classes necessárias do Agent Framework:

import asyncio
from agent_framework.github import GitHubCopilotAgent, GitHubCopilotOptions

Criar um Agente Copilot do GitHub

Criação básica de agente

A maneira mais simples de criar um agente do 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)

Com configuração explícita

Você pode fornecer uma configuração explícita por meio do elemento 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 (e, por execução, options) encaminha qualquer parâmetro aceito pelo create_session do SDK do Copilot — por exemplo, reasoning_effort, context_tier, enable_citations, provider (use sua própria chave) ou skill_directories — não apenas as chaves mostradas aqui. Nomes de parâmetros desconhecidos resultam em um TypeError, assim erros de digitação são detectados em vez de serem ignorados silenciosamente.

traga sua própria chave (BYOK)

Utilize o suporte a BYOK do SDK do Copilot para rotear solicitações de modelo por meio do seu próprio endpoint (seja da OpenAI, OpenAI do Azure, Anthropic ou compatível com a OpenAI) em vez de utilizar o backend do GitHub Copilot. Passe um(a) ProviderConfig por GitHubCopilotOptions(provider=...) e defina o mesmo identificador de modelo tanto na configuração do provedor quanto na opção model no nível da sessão.

O exemplo executável usa estas variáveis de ambiente:

Variable	Description
BYOK_PROVIDER_TYPE	Tipo de provedor: openai, azureou anthropic. Usa openai como padrão.
BYOK_BASE_URL	URL base para o endpoint do provedor.
BYOK_API_KEY	Chave de API estática para o endpoint do provedor.
BYOK_MODEL_ID	Identificador de modelo a ser solicitado. Usa gpt-4o como padrão.

O exemplo usa uma chave de API estática. Para alternar as credenciais, defina o campo experimental bearer_token_provider em ProviderConfig como um callback síncrono ou assíncrono que retorna um token. O SDK do Copilot invoca o callback para cada solicitação ao provedor, e o callback é responsável pela aquisição, pelo armazenamento em cache e pela renovação de tokens. Um provedor de token bearer tem precedência sobre api_key ou bearer_token quando eles também estão definidos.

Aviso

Mantenha as chaves e tokens de API estáticos fora do controle do código-fonte. Carregue-as de variáveis de ambiente ou de um repositório secreto. Seu provedor, não GitHub, controla o uso e a cobrança.

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

Funcionalidades do agente

Provedores de contexto

O Python também oferece suporte a GitHubCopilotAgentcontext_providers=[...]. Os provedores são executados antes e depois de cada invocação, portanto, as mensagens e instruções adicionadas pelo provedor são incluídas no prompt do Copilot e os provedores de histórico podem observar a resposta final.

from agent_framework import InMemoryHistoryProvider

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

Você pode combinar provedores de histórico internos com provedores de contexto personalizados. Para padrões de implementação, consulte Provedores de Contexto.

Ferramentas de Funções

Equipe seu agente com funções personalizadas:

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)

Respostas de transmissão contínua

Obtenha respostas conforme elas são geradas para uma melhor experiência do usuário:

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

Gerenciamento de threads

Manter o contexto da conversa em várias interações:

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

Por padrão, o agente não pode executar comandos de shell, arquivos de leitura/gravação ou buscar URLs. Para habilitar esses recursos, forneça um manipulador de permissões:

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)

Para ambientes confiáveis em que todas as permissões devem ser aprovadas automaticamente, use o recurso interno PermissionHandler.approve_all:

from copilot.session import PermissionHandler

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

Os manipuladores de permissão oferecem suporte a callbacks síncronos e assíncronos. Use asyncio.to_thread para prompts interativos em manipuladores assíncronos para evitar bloquear o loop de eventos.

Aprovação da ferramenta

Como o SDK do GitHub Copilot gerencia o loop de chamada de ferramentas, a aprovação para ferramentas de funções personalizadas é aplicada por meio do hook de pré-execução nativo do SDK, em vez do fluxo padrão de aprovação do Agent Framework. Quando você registra uma ferramenta declarada com approval_mode="always_require" e não fornece seu próprio gancho on_pre_tool_use, o agente instala um gancho padrão que retorna "ask" para essa ferramenta e encaminha a decisão para seu manipulador 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),
)

Aviso

Se você fornecer seu próprio hook on_pre_tool_use, ele terá precedência, e o agente não instalará seu hook de aprovação padrão. Em seguida, você é totalmente responsável por garantir a aprovação de qualquer ferramenta approval_mode="always_require" (por exemplo, retornando uma decisão "deny" ou "ask"). O agente registra um aviso identificando qualquer ferramenta que exija aprovação e que o seu hook deva processar. Com o manipulador de permissões padrão de negação total, uma ferramenta always_require é negada, a menos que você conecte um componente de aprovação on_permission_request.

Servidores MCP

Conecte-se a servidores MCP locais (stdio) ou remotos (HTTP) para recursos estendidos:

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 possui rastreamento OpenTelemetry incorporado. Chame configure_otel_providers() uma vez na inicialização para habilitar intervalos, métricas e logs para cada execução:

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

Se você precisar do agente subjacente sem a camada de telemetria (por exemplo, para encapsulá-lo em um personalizado), importe RawGitHubCopilotAgent de agent_framework.github.

Para exportadores OTLP e exemplos mais ricos, consulte os exemplos de observabilidade.

Tools

Tool	Status	Notes
Ferramentas de Funções	✅	Chamáveis Python padrão ou @ai_function.
Aprovação da ferramenta	✅	Fornecido pelo cliente de chat com invocação de funções da estrutura; funciona com qualquer chamada de ferramenta de função.
Interpretador de Código	❌	Não é um recurso do Copilot CLI.
Pesquisa de Arquivo	❌	Não é um recurso do Copilot CLI.
Pesquisa na Web	❌	Não está disponível como uma ferramenta hospedada.
Shell/sistema de arquivos/busca de URL	✅	Integrado ao ambiente de execução da CLI do Copilot e controlado pelo manipulador Permissions que você fornece.
Ferramentas MCP hospedadas	✅	Servidores MCP remotos (HTTP) configurados por meio de default_options["mcp_servers"]. Consulte servidores MCP.
Ferramentas MCP locais	✅	Servidores MCP locais (stdio) configurados por meio de default_options["mcp_servers"]. Consulte servidores MCP.

Usando o agente

O agente é um BaseAgent padrão e suporta todas as operações de agente padrão.

Para obter mais informações sobre como executar e interagir com agentes, consulte os tutoriais de introdução do Agente.

Introdução

Instale o módulo do Microsoft Agent Framework Go e o SDK do GitHub Copilot para Go. O SDK do Agent Framework Go requer o Go 1.25 ou posterior.

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

Criar um Agente Copilot do GitHub

Crie e inicie um copilot.Cliente, em seguida, passe-o para 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)

Com ferramentas e instruções

Você pode fornecer ferramentas de função e instruções personalizadas ao criar o agente:

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)

Funcionalidades do agente

Respostas de transmissão contínua

Obtenha respostas conforme elas são geradas:

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

Gerenciamento da sessão

Mantenha o contexto de conversa em várias interações usando sessões:

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

Por padrão, o agente não pode executar comandos de shell, arquivos de leitura/gravação ou buscar URLs. Para habilitar esses recursos, forneça um manipulador de permissões por meio de 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)

Servidores MCP

Conecte-se a servidores MCP locais (stdio) ou remotos (HTTP) para recursos estendidos:

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

Consulte o exemplo go GitHub Copilot para obter um exemplo executável completo.

Tools

Tool	Status	Notes
Ferramentas de Funções	✅	Instâncias padrão do Go tool.Tool, incluindo funções functool.
Aprovação da ferramenta	✅	As ferramentas de funções podem usar o suporte padrão à aprovação de ferramentas do Go; as permissões de runtime do Copilot são tratadas por SessionConfig.OnPermissionRequest.
Interpretador de Código	❌	Não é um recurso do Copilot CLI.
Pesquisa de Arquivo	❌	Não é um recurso do Copilot CLI.
Pesquisa na Web	❌	Não está disponível como uma ferramenta hospedada.
Shell/sistema de arquivos/busca de URL	✅	Integrado ao ambiente de execução da CLI do Copilot e controlado pelo manipulador Permissions que você fornece.
Ferramentas MCP hospedadas	✅	Servidores MCP remotos (HTTP) configurados por meio de copilot.SessionConfig.MCPServers. Consulte servidores MCP.
Ferramentas MCP locais	✅	Servidores MCP locais (stdio) configurados por meio de copilot.SessionConfig.MCPServers. Consulte servidores MCP.

Usando o agente

O agente é um *agent.Agent padrão e suporta todas as operações de agente padrão.

Para obter mais informações sobre como executar e interagir com agentes, consulte os tutoriais de introdução do Agente.

Próximas Etapas 

Copilot Studio