GitHub Copilot

Microsoft Agent Framework admite la creación de agentes que usan el SDK de Copilot de GitHub como back-end. Los agentes de GitHub Copilot proporcionan acceso a eficaces funcionalidades de inteligencia artificial orientadas a codificación, como la ejecución de comandos de shell, las operaciones de archivo, la captura de direcciones URL y la integración del servidor del Protocolo de contexto de modelo (MCP).

Importante

los agentes de GitHub Copilot requieren un entorno de ejecución de GitHub Copilot autenticado. Algunos SDK usan una CLI instalada, mientras que el SDK de Go usa el entorno de ejecución agrupado de forma predeterminada. Por seguridad, se recomienda ejecutar agentes con permisos de shell o archivo en un entorno contenedorizado (Docker/Dev Container).

Getting Started

Agregue los paquetes NuGet necesarios al proyecto.

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

Creación de un agente de Copilot de GitHub

Como primer paso, cree un CopilotClient y inícielo. A continuación, use el método de AsAIAgent extensión para crear un 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?"));

Con herramientas e instrucciones

Puede proporcionar herramientas de función e instrucciones personalizadas al crear el 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?"));

Características del agente

Respuestas de streaming

Obtenga respuestas a medida que se generen:

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

Administración de sesiones

Mantener el contexto de conversación en varias interacciones mediante sesiones:

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

De forma predeterminada, el agente no puede ejecutar comandos de shell, archivos de lectura y escritura ni capturar direcciones URL. Para habilitar estas funcionalidades, proporcione un controlador de permisos mediante 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"));

Aprobación de herramientas

Dado que el SDK de GitHub Copilot posee el bucle de llamada a herramientas, la aprobación de las herramientas de funciones personalizadas se aplica a través del enlace nativo de preecución del SDK en lugar del recorrido de ida y vuelta estándar de aprobación de Agent Framework. Al registrar una herramienta encapsulada en ApprovalRequiredAIFunction, el agente instala un enlace predeterminado OnPreToolUse que devuelve "ask" esa herramienta y enruta la decisión al OnPermissionRequest controlador:

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

Si proporciona su propio OnPreToolUse enlace a través SessionConfig.Hooksde , tiene prioridad y el agente no instala su enlace de aprobación predeterminado. A continuación, usted es totalmente responsable de aplicar la aprobación de cualquier ApprovalRequiredAIFunction registro (por ejemplo, devolviendo una "deny" decisión o "ask" ). El agente registra una advertencia que denomina cualquier herramienta necesaria para aprobación que el enlace debe controlar.

Servidores MCP

Conéctese a servidores MCP locales (stdio) o remotos (HTTP) para funcionalidades extendidas:

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 los ejemplos de .NET para obtener ejemplos completos de ejecución.

Tools

Herramienta	Situación	Notas
Herramientas de funciones	✅	Instancias estándar AIFunction .
Aprobación de herramientas	✅	Proporcionado por el cliente de chat con invocación de funciones del framework; funciona con cualquier llamada a una función-herramienta.
Intérprete de código	❌	No es una funcionalidad de la CLI de Copilot.
Búsqueda de archivos	❌	No es una funcionalidad de la CLI de Copilot.
Búsqueda web	❌	No está disponible como una herramienta alojada.
Shell / sistema de archivos / obtención de URL	✅	Integrado en el entorno de ejecución de la CLI de Copilot y supeditado al controlador Permissions que proporciones.
Herramientas de MCP hospedadas	✅	Servidores MCP remotos (HTTP) configurados mediante SessionConfig.McpServers. Consulte Servidores MCP.
Herramientas de MCP locales	✅	Servidores MCP locales (stdio) configurados a través de SessionConfig.McpServers. Consulte Servidores MCP.

Uso del agente

El agente es un AIAgent estándar y admite todas las operaciones estándar AIAgent.

Para obtener más información sobre cómo ejecutar e interactuar con agentes, consulte los tutoriales de introducción al agente.

Prerequisites

Instale el paquete de GitHub Copilot de Microsoft Agent Framework.

pip install agent-framework-github-copilot

Configuration

El agente se puede configurar opcionalmente mediante las siguientes variables de entorno:

Variable	Description
GITHUB_COPILOT_CLI_PATH	Ruta de acceso al ejecutable de la CLI de Copilot
GITHUB_COPILOT_MODEL	Modelo que se va a usar (por ejemplo, gpt-5, claude-sonnet-4)
GITHUB_COPILOT_TIMEOUT	Tiempo de espera de solicitud en segundos
GITHUB_COPILOT_LOG_LEVEL	Nivel de registro de la CLI
GITHUB_COPILOT_BASE_DIRECTORY	Directorio para el estado de sesión y la configuración de la CLI (el valor predeterminado es ~/.copilot)

Getting Started

Importe las clases necesarias desde Agent Framework:

import asyncio
from agent_framework.github import GitHubCopilotAgent, GitHubCopilotOptions

Creación de un agente de Copilot de GitHub

Creación básica del agente

La manera más sencilla de crear un agente de 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)

Con configuración explícita

Puede proporcionar una configuración explícita a travé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(y por ejecución options) reenvía cualquier parámetro aceptado por el SDK de create_session Copilot ( por ejemploreasoning_effort, , context_tier, enable_citations, provider (bring-your-own-key) o skill_directories , no solo las claves que se muestran aquí. Los nombres de parámetro desconocidos generan un TypeError, por lo que los errores tipográficos se detectan en lugar de omitirse silenciosamente.

Bring Your Own Key (BYOK)

Use la compatibilidad con BYOK del SDK de Copilot para enrutar las solicitudes del modelo a través de su propio OpenAI, Azure OpenAI, Anthropic o un punto de conexión compatible con OpenAI en lugar del back-end de GitHub Copilot. Pase a ProviderConfig través GitHubCopilotOptions(provider=...)de y establezca el mismo identificador de modelo en la configuración del proveedor y la opción de nivel model de sesión.

El ejemplo ejecutable usa estas variables de entorno:

Variable	Description
BYOK_PROVIDER_TYPE	Tipo de proveedor: openai, azureo anthropic. Tiene como valor predeterminado openai.
BYOK_BASE_URL	Dirección URL base del punto de conexión del proveedor.
BYOK_API_KEY	Clave de API estática para el punto de conexión del proveedor.
BYOK_MODEL_ID	Identificador de modelo que se va a solicitar. Tiene como valor predeterminado gpt-4o.

Warning

BYOK usa credenciales estáticas y no proporciona la actualización automática de tokens. Mantenga las claves de API fuera del control de código fuente y cárgelas desde variables de entorno o desde un almacén de secretos. El proveedor realiza un seguimiento del uso y la facturación en lugar de 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")

Características del agente

Proveedores de contexto

Python GitHubCopilotAgent también admite context_providers=[...]. Los proveedores se ejecutan antes y después de cada invocación, por lo que los mensajes e instrucciones agregados por el proveedor se incluyen en el mensaje de Copilot y los proveedores de historial pueden observar la respuesta final.

from agent_framework import InMemoryHistoryProvider

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

Puede combinar proveedores de historial integrados con proveedores de contexto personalizados. Para conocer los patrones de implementación, consulte Proveedores de contexto.

Herramientas de funciones

Equipe al agente con funciones 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)

Respuestas de streaming

Obtenga respuestas a medida que se generen para mejorar la experiencia del usuario:

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

Administración de subprocesos

Mantener el contexto de conversación en varias interacciones:

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

De forma predeterminada, el agente no puede ejecutar comandos de shell, archivos de lectura y escritura ni capturar direcciones URL. Para habilitar estas funcionalidades, proporcione un controlador de permisos:

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 entornos de confianza en los que todos los permisos deben aprobarse automáticamente, use el elemento integrado PermissionHandler.approve_all:

from copilot.session import PermissionHandler

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

Los manejadores de permisos admiten funciones de callback síncronas y asíncronas. Use asyncio.to_thread para avisos interactivos en controladores asincrónicos para evitar el bloqueo del bucle de eventos.

Aprobación de herramientas

Dado que el SDK de GitHub Copilot posee el bucle de llamada a herramientas, la aprobación de las herramientas de funciones personalizadas se aplica a través del enlace nativo de preecución del SDK en lugar del recorrido de ida y vuelta estándar de aprobación de Agent Framework. Cuando registra una herramienta declarada con approval_mode="always_require" y no proporciona su propio on_pre_tool_use enlace, el agente instala un enlace predeterminado que devuelve "ask" para esa herramienta y enruta la decisión al on_permission_request controlador:

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

Si proporciona su propio on_pre_tool_use enlace, tiene prioridad y el agente no instala su enlace de aprobación predeterminado. A continuación, es totalmente responsable de aplicar la aprobación de cualquier approval_mode="always_require" herramienta (por ejemplo, devolviendo una "deny" decisión o "ask" ). El agente registra una advertencia que denomina cualquier herramienta necesaria para aprobación que el enlace debe controlar. Con el controlador de permisos deny-all predeterminado, se deniega una always_require herramienta a menos que conecte una aprobación on_permission_request.

Servidores MCP

Conéctese a servidores MCP locales (stdio) o remotos (HTTP) para funcionalidades extendidas:

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 tiene integrado el seguimiento de OpenTelemetry. Llame configure_otel_providers() una vez al inicio para habilitar intervalos, métricas y registros para cada ejecució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!")

Si necesita el agente subyacente sin la capa de telemetría (por ejemplo, para envolverlo en uno personalizado), importe RawGitHubCopilotAgent desde agent_framework.github.

Para los exportadores de OTLP y ejemplos más detallados, consulte las muestras de observabilidad.

Tools

Herramienta	Situación	Notas
Herramientas de funciones	✅	Callables estándar de Python o @ai_function.
Aprobación de herramientas	✅	Proporcionado por el cliente de chat con invocación de funciones del framework; funciona con cualquier llamada a una función-herramienta.
Intérprete de código	❌	No es una funcionalidad de la CLI de Copilot.
Búsqueda de archivos	❌	No es una funcionalidad de la CLI de Copilot.
Búsqueda web	❌	No está disponible como una herramienta alojada.
Shell / sistema de archivos / obtención de URL	✅	Integrado en el entorno de ejecución de la CLI de Copilot y controlado por el controlador Permissions que proporciones.
Herramientas de MCP hospedadas	✅	Servidores MCP remotos (HTTP) configurados mediante default_options["mcp_servers"]. Consulte Servidores MCP.
Herramientas de MCP locales	✅	Servidores MCP locales (stdio) configurados a través de default_options["mcp_servers"]. Consulte Servidores MCP.

Uso del agente

El agente es un estándar BaseAgent y admite todas las operaciones estándar.

Para obtener más información sobre cómo ejecutar e interactuar con agentes, consulte los tutoriales de introducción al agente.

Getting Started

Instale el módulo Microsoft Agent Framework Go y el SDK de GitHub Copilot para Go. El SDK de Agent Framework Go requiere Go 1.25 o posterior.

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

Creación de un agente de Copilot de GitHub

Cree e inicie un copilot.Client, y a continuación páselo a 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)

Con herramientas e instrucciones

Puede proporcionar herramientas de función e instrucciones personalizadas al crear el 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)

Características del agente

Respuestas de streaming

Obtenga respuestas a medida que se generen:

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

Administración de sesiones

Mantener el contexto de conversación en varias interacciones mediante sesiones:

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

De forma predeterminada, el agente no puede ejecutar comandos de shell, archivos de lectura y escritura ni capturar direcciones URL. Para habilitar estas funcionalidades, proporcione un controlador de permisos mediante 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

Conéctese a servidores MCP locales (stdio) o remotos (HTTP) para funcionalidades extendidas:

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 el ejemplo de Go GitHub Copilot para obtener un ejemplo completo de ejecución.

Tools

Herramienta	Situación	Notas
Herramientas de funciones	✅	Instancias estándar de Go tool.Tool, incluidas las funciones functool.
Aprobación de herramientas	✅	Las herramientas de función pueden usar la compatibilidad estándar para la aprobación de herramientas de Go; los permisos de tiempo de ejecución de Copilot los gestiona SessionConfig.OnPermissionRequest.
Intérprete de código	❌	No es una funcionalidad de la CLI de Copilot.
Búsqueda de archivos	❌	No es una funcionalidad de la CLI de Copilot.
Búsqueda web	❌	No está disponible como una herramienta alojada.
Shell / sistema de archivos / obtención de URL	✅	Integrado en el entorno de ejecución de la CLI de Copilot y controlado por el controlador Permissions que proporciones.
Herramientas de MCP hospedadas	✅	Servidores MCP remotos (HTTP) configurados mediante copilot.SessionConfig.MCPServers. Consulte Servidores MCP.
Herramientas de MCP locales	✅	Servidores MCP locales (stdio) configurados a través de copilot.SessionConfig.MCPServers. Consulte Servidores MCP.

Uso del agente

El agente es un estándar *agent.Agent y admite todas las operaciones estándar.

Para obtener más información sobre cómo ejecutar e interactuar con agentes, consulte los tutoriales de introducción al agente.

Pasos siguientes

Copilot Studio