GitHub Copilot

O Microsoft Agent Framework suporta a criação de agentes que utilizam o GitHub Copilot SDK como backend. Os agentes GitHub Copilot fornecem acesso a poderosas capacidades de IA orientadas para programação, incluindo execução de comandos shell, operações de ficheiros, obtenção de URLs e integração com servidores Model Context Protocol (MCP).

Importante

Os agentes GitHub Copilot requerem um runtime GitHub Copilot autenticado. Alguns SDKs usam uma CLI instalada, enquanto o Go SDK usa o runtime incluído por defeito. Para segurança, recomenda-se executar agentes com permissões de shell ou ficheiro num ambiente containerizado (Docker/Dev Container).

Introdução

Adicione os pacotes NuGet necessários ao seu projeto.

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

Criar um agente do GitHub Copilot

Como primeiro passo, crie um CopilotClient e comece. Depois, use o método de extensão AsAIAgent 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

Pode fornecer ferramentas funcionais 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 streaming

Obtenha respostas à medida que forem 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();

Gestão de Sessões

Mantenha o contexto da conversa em múltiplas 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 defeito, o agente não pode executar comandos de shell, ler/escrever ficheiros ou buscar URLs. Para ativar estas capacidades, forneça um manipulador de permissões através 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 de Ferramentas

Como o SDK do GitHub Copilot detém o ciclo de chamada de ferramentas, a aprovação para ferramentas de funções personalizadas é aplicada através do hook nativo de pré-execução do SDK, em vez do tradicional percurso de aprovação do Agent Framework. Quando registas uma ferramenta envolvida em ApprovalRequiredAIFunction, o agente instala um hook padrão OnPreToolUse que retorna "ask" para essa ferramenta e encaminha a decisão para o teu OnPermissionRequest handler:

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

Se fornecer o seu próprio OnPreToolUse hook via SessionConfig.Hooks, ele tem prioridade e o agente não instala o seu hook de aprovação padrão. Depois, é totalmente responsável por fazer cumprir a aprovação de qualquer decisão ApprovalRequiredAIFunction que registe (por exemplo, devolvendo uma "deny" decisão de OR "ask" ). O agente regista um aviso nomeando qualquer ferramenta que o gancho precise de aprovação.

Servidores MCP

Ligue-se a servidores MCP locais (stdio) ou remotos (HTTP) para capacidades alargadas:

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 exemplos completos executáveis.

Tools

Tool	Situação	Notes
Ferramentas Funcionais	✅	Instâncias padrão AIFunction.
Aprovação de Ferramentas	✅	Fornecido pelo cliente de chat de invocação de funções do framework; Funciona com qualquer chamada de ferramenta funcional.
Intérprete de código	❌	Não é uma funcionalidade do Copilot CLI.
Pesquisa de ficheiros	❌	Não é uma funcionalidade do Copilot CLI.
Pesquisa na Web	❌	Não disponível como ferramenta alojada.
Shell / sistema de ficheiros / obtenção de URL	✅	Integrado no runtime da Copilot CLI e bloqueado pelo handler Permissions que forneces.
Ferramentas alojadas do MCP	✅	Servidores MCP remotos (HTTP) configurados via SessionConfig.McpServers. Ver Servidores MCP.
Ferramentas MCP Locais	✅	Servidores locais (stdio) MCP configurados via SessionConfig.McpServers. Ver Servidores MCP.

Usando o agente

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

Para mais informações sobre como gerir e interagir com agentes, consulte os tutoriais de Início de Agentes.

Pré-requisitos

Instala o pacote Microsoft Agent Framework GitHub Copilot.

pip install agent-framework-github-copilot

Configuration

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

Variável	Description
GITHUB_COPILOT_CLI_PATH	Caminho para o executável da CLI Copilot
GITHUB_COPILOT_MODEL	Modelo a usar (por exemplo, gpt-5, claude-sonnet-4)
GITHUB_COPILOT_TIMEOUT	Peça tempo limite em segundos
GITHUB_COPILOT_LOG_LEVEL	Nível de log do CLI
GITHUB_COPILOT_BASE_DIRECTORY	Diretório do estado da sessão e da configuração da CLI (predefinido como ~/.copilot)

Introdução

Importar as classes necessárias do Agent Framework:

import asyncio
from agent_framework.github import GitHubCopilotAgent, GitHubCopilotOptions

Criar um agente do GitHub Copilot

Criação básica de agentes

A forma mais simples de criar um agente 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

Pode fornecer uma configuração explícita através de 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 corridaoptions) encaminha qualquer parâmetro aceite pelos SDKs create_session do Copilot — por exemplo reasoning_effort, context_tier, enable_citations, provider (traga-a-sua-própria-chave), ou skill_directories — não apenas as chaves aqui mostradas. Nomes de parâmetros desconhecidos geram um TypeError, por isso erros tipográficos são detetados em vez de ignorados silenciosamente.

Traga sua própria chave (BYOK)

Use o suporte BYOK do Copilot SDK para encaminhar pedidos de modelo através do seu próprio endpoint OpenAI, Azure OpenAI, Anthropic ou compatível com OpenAI, em vez do backend do GitHub Copilot. Passe a ProviderConfig através GitHubCopilotOptions(provider=...)de , e defina o mesmo identificador de modelo tanto na configuração do fornecedor como na opção ao nível model da sessão.

A amostra executável utiliza estas variáveis de ambiente:

Variável	Description
BYOK_PROVIDER_TYPE	Tipo de fornecedor: openai, azure, ou anthropic. O valor padrão é openai.
BYOK_BASE_URL	URL base para o endpoint do fornecedor.
BYOK_API_KEY	Chave API estática para o endpoint do fornecedor.
BYOK_MODEL_ID	Identificador de modelo a solicitar. O valor padrão é gpt-4o.

Warning

O BYOK usa credenciais estáticas e não fornece atualização automática de tokens. Mantenha as chaves API fora do controlo de versões e carregue-as a partir de variáveis de ambiente ou de um armazenamento secreto. O uso e a faturação são monitorizados pelo seu fornecedor em vez do 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")

Funcionalidades do agente

Fornecedores de Contexto

O Python GitHubCopilotAgent também suporta context_providers=[...]. Os fornecedores operam antes e depois de cada chamada, pelo que mensagens e instruções adicionadas pelo fornecedor são incluídas no prompt do Copilot e os fornecedores de histórico conseguem observar a resposta final.

from agent_framework import InMemoryHistoryProvider

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

Pode combinar fornecedores de histórico incorporados com fornecedores de contexto personalizados. Para padrões de implementação, consulte Fornecedores de Contexto.

Ferramentas de Função

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 streaming

Obtenha respostas à medida que são geradas para uma melhor experiência do utilizador:

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

Mantenha o contexto da conversa ao longo de múltiplas 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 defeito, o agente não pode executar comandos de shell, ler/escrever ficheiros ou buscar URLs. Para ativar estas capacidades, 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 fidedignos em que todas as permissões devam ser aprovadas automaticamente, utilize a opção integrada PermissionHandler.approve_all:

from copilot.session import PermissionHandler

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

Os processadores de permissões suportam tanto callbacks síncronos como assíncronos. Utilize asyncio.to_thread para pedidos interativos em processadores assíncronos para evitar o bloqueio do ciclo de eventos.

Aprovação de Ferramentas

Como o SDK do GitHub Copilot detém o ciclo de chamada de ferramentas, a aprovação para ferramentas de funções personalizadas é aplicada através do hook nativo de pré-execução do SDK, em vez do tradicional percurso de aprovação do Agent Framework. Quando regista uma ferramenta declarada com approval_mode="always_require" e não fornece o seu próprio on_pre_tool_use hook, o agente instala um hook padrão que retorna "ask" essa ferramenta e encaminha a decisão para o seu on_permission_request handler:

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

Se fornecer o seu próprio on_pre_tool_use hook, ele tem prioridade e o agente não instala o seu hook de aprovação padrão. Fica então totalmente responsável por fazer cumprir a aprovação de qualquer approval_mode="always_require" ferramenta (por exemplo, ao devolver uma "deny" decisão de OR "ask" ). O agente regista um aviso nomeando qualquer ferramenta que o gancho precise de aprovação. Com o manipulador de permissões por defeito, uma always_require ferramenta é recusada a menos que faça uma ligação de aprovação on_permission_request.

Servidores MCP

Ligue-se a servidores MCP locais (stdio) ou remotos (HTTP) para capacidades alargadas:

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 tem rastreamento OpenTelemetry incorporado. Chame configure_otel_providers() uma vez na inicialização para ativar spans, métricas e logs para todas as execuções.

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 precisares do agente subjacente sem a camada de telemetria (por exemplo, para a envolver numa camada personalizada), importa RawGitHubCopilotAgent de agent_framework.github.

Para exportadores OTLP e exemplos mais detalhados, consulte as amostras de observabilidade.

Tools

Tool	Situação	Notes
Ferramentas Funcionais	✅	Objetos invocáveis padrão de Python ou @ai_function.
Aprovação de Ferramentas	✅	Fornecido pelo cliente de chat de invocação de funções do framework; Funciona com qualquer chamada de ferramenta funcional.
Intérprete de código	❌	Não é uma funcionalidade do Copilot CLI.
Pesquisa de ficheiros	❌	Não é uma funcionalidade do Copilot CLI.
Pesquisa na Web	❌	Não disponível como ferramenta alojada.
Shell / sistema de ficheiros / obtenção de URL	✅	Integrado no ambiente de execução da Copilot CLI e controlado pelo processador Permissions que fornecer.
Ferramentas alojadas do MCP	✅	Servidores MCP remotos (HTTP) configurados via default_options["mcp_servers"]. Ver Servidores MCP.
Ferramentas MCP Locais	✅	Servidores locais (stdio) MCP configurados via default_options["mcp_servers"]. Ver Servidores MCP.

Usando o agente

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

Para mais informações sobre como gerir e interagir com agentes, consulte os tutoriais de Início de Agentes.

Introdução

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

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

Criar um agente do GitHub Copilot

Crie e inicie um copilot.Client, depois passe 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

Pode fornecer ferramentas funcionais 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 streaming

Obtenha respostas à medida que forem 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()

Gestão de Sessões

Mantenha o contexto da conversa em múltiplas 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 defeito, o agente não pode executar comandos de shell, ler/escrever ficheiros ou buscar URLs. Para ativar estas capacidades, forneça um manipulador de permissões através 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

Ligue-se a servidores MCP locais (stdio) ou remotos (HTTP) para capacidades alargadas:

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

Veja o exemplo do Go GitHub Copilot para um exemplo completo e executável.

Tools

Tool	Situação	Notes
Ferramentas Funcionais	✅	Instâncias padrão do Go tool.Tool, incluindo funções functool.
Aprovação de Ferramentas	✅	As ferramentas funcionais podem usar o suporte padrão de aprovação de ferramentas Go; As permissões de runtime do Copilot são tratadas por SessionConfig.OnPermissionRequest.
Intérprete de código	❌	Não é uma funcionalidade do Copilot CLI.
Pesquisa de ficheiros	❌	Não é uma funcionalidade do Copilot CLI.
Pesquisa na Web	❌	Não disponível como ferramenta alojada.
Shell / sistema de ficheiros / obtenção de URL	✅	Integrado no ambiente de execução da Copilot CLI e controlado pelo processador Permissions que fornecer.
Ferramentas alojadas do MCP	✅	Servidores MCP remotos (HTTP) configurados via copilot.SessionConfig.MCPServers. Ver Servidores MCP.
Ferramentas MCP Locais	✅	Servidores locais (stdio) MCP configurados via copilot.SessionConfig.MCPServers. Ver Servidores MCP.

Usando o agente

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

Para mais informações sobre como gerir e interagir com agentes, consulte os tutoriais de Início de Agentes.

Passos seguintes

Estúdio Copiloto