Skip to main content Inicio Creadores beko2210 firstbrain copilot-sdk
copilot-sdk Build applications that programmatically interact with GitHub Copilot. The SDK wraps the Copilot CLI via JSON-RPC, providing session management, custom tools, hooks, MCP server integration, and streaming across Node.js, Python, Go, and .NET.
Ir a la instalación Skills Marketplace Descubre y explora habilidades de IA creadas por la comunidad.
Ocupaciones relacionadas SOC
Basado en la clasificación ocupacional SOC
Instalar con Codex o Claude Copia este prompt, pégalo en Codex, Claude u otro asistente, y deja que revise la página de la skill y la instale por ti.
Mostrar detalles del prompt Un comando directo omite el prompt de revisión. Revisa el origen antes de ejecutarlo.
npx skills add https://github.com/BEKO2210/Firstbrain --skill copilot-sdkEl comando permanece en una sola línea. Desplázate horizontalmente para revisarlo antes de copiarlo.
¿Prefieres una copia local? Descarga los archivos que SkillsMP tiene disponibles ahora.
Descargar Zip Descargando... name copilot-sdk description Build applications that programmatically interact with GitHub Copilot. The SDK wraps the Copilot CLI via JSON-RPC, providing session management, custom tools, hooks, MCP server integration, and streaming across Node.js, Python, Go, and .NET. type skill created 2026-02-27T00:00:00.000Z domain software-development category devtools risk unknown source community tags ["skill","software-development","devtools","copilot","sdk"]
GitHub Copilot SDK
Build applications that programmatically interact with GitHub Copilot. The SDK wraps the Copilot CLI via JSON-RPC, providing session management, custom tools, hooks, MCP server integration, and streaming across Node.js, Python, Go, and .NET.
Prerequisites
GitHub Copilot CLI installed and authenticated (copilot --version to verify)GitHub Copilot subscription (Individual, Business, or Enterprise) — not required for BYOKRuntime: Node.js 18+ / Python 3.8+ / Go 1.21+ / .NET 8.0+
Installation
Language Package Install Node.js @github/copilot-sdknpm install @github/copilot-sdkPython github-copilot-sdkpip install github-copilot-sdkGo github.com/github/copilot-sdk/gogo get github.com/github/copilot-sdk/go.NET GitHub.Copilot.SDKdotnet add package GitHub.Copilot.SDK
Core Pattern: Client → Session → Message
All SDK usage follows this pattern: create a client, create a session, send messages.
Node.js / TypeScript
import { CopilotClient } from "@github/copilot-sdk" ;
const client = new CopilotClient ();
const session = await client.createSession ({ model : "gpt-4.1" });
const response = await session.sendAndWait ({ prompt : "What is 2 + 2?" });
console .log
data
content
await
stop
Python import asyncio
from copilot import CopilotClient
async def main ():
client = CopilotClient()
await client.start()
session = await client.create_session({"model" : "gpt-4.1" })
response = await session.send_and_wait({"prompt" : "What is 2 + 2?" })
print (response.data.content)
await client.stop()
asyncio.run(main())
Go client := copilot.NewClient(nil )
if err := client.Start(ctx); err != nil { log.Fatal(err) }
defer client.Stop()
session, _ := client.CreateSession(ctx, &copilot.SessionConfig{Model: "gpt-4.1" })
response, _ := session.SendAndWait(ctx, copilot.MessageOptions{Prompt: "What is 2 + 2?" })
fmt.Println(*response.Data.Content)
.NET await using var client = new CopilotClient();
await using var session = await client.CreateSessionAsync(new SessionConfig { Model = "gpt-4.1" });
var response = await session.SendAndWaitAsync(new MessageOptions { Prompt = "What is 2 + 2?" });
Console.WriteLine(response?.Data.Content);
Streaming Responses Enable real-time output by setting streaming: true and subscribing to delta events.
const session = await client.createSession ({ model : "gpt-4.1" , streaming : true });
session.on ("assistant.message_delta" , (event ) => {
process.stdout .write (event.data .deltaContent );
});
session.on ("session.idle" , () => console .log ());
await session.sendAndWait ({ prompt : "Tell me a joke" });
from copilot.generated.session_events import SessionEventType
session = await client.create_session({"model" : "gpt-4.1" , "streaming" : True })
def handle_event (event ):
if event.type == SessionEventType.ASSISTANT_MESSAGE_DELTA:
sys.stdout.write(event.data.delta_content)
sys.stdout.flush()
session.on(handle_event)
await session.send_and_wait({"prompt" : "Tell me a joke" })
Event Subscription Method Description on(handler)Subscribe to all events; returns unsubscribe function on(eventType, handler)Subscribe to specific event type (Node.js only)
Custom Tools Define tools that Copilot can call to extend its capabilities.
Node.js import { CopilotClient , defineTool } from "@github/copilot-sdk" ;
const getWeather = defineTool ("get_weather" , {
description : "Get the current weather for a city" ,
parameters : {
type : "object" ,
properties : { city : { type : "string" , description : "The city name" } },
required : ["city" ],
},
handler : async ({ city }) => ({ city, temperature : "72°F" , condition : "sunny" }),
});
const session = await client.createSession ({
model : "gpt-4.1" ,
tools : [getWeather],
});
Python from copilot.tools import define_tool
from pydantic import BaseModel, Field
class GetWeatherParams (BaseModel ):
city: str = Field(description="The city name" )
@define_tool(description="Get the current weather for a city" )
async def get_weather (params: GetWeatherParams ) -> dict :
return {"city" : params.city, "temperature" : "72°F" , "condition" : "sunny" }
session = await client.create_session({"model" : "gpt-4.1" , "tools" : [get_weather]})
Go type WeatherParams struct {
City string `json:"city" jsonschema:"The city name"`
}
getWeather := copilot.DefineTool("get_weather" , "Get weather for a city" ,
func (params WeatherParams, inv copilot.ToolInvocation) error ) {
return WeatherResult{City: params.City, Temperature: "72°F" }, nil
},
)
session, _ := client.CreateSession(ctx, &copilot.SessionConfig{
Model: "gpt-4.1" ,
Tools: []copilot.Tool{getWeather},
})
.NET var getWeather = AIFunctionFactory.Create(
([Description("The city name" )] string city) => new { city, temperature = "72°F" },
"get_weather" , "Get the current weather for a city" );
await using var session = await client.CreateSessionAsync(new SessionConfig {
Model = "gpt-4.1" , Tools = [getWeather],
});
Hooks Intercept and customize session behavior at key lifecycle points.
Hook Trigger Use Case onPreToolUseBefore tool executes Permission control, argument modification onPostToolUseAfter tool executes Result transformation, logging onUserPromptSubmittedUser sends message Prompt modification, filtering onSessionStartSession begins Add context, configure session onSessionEndSession ends Cleanup, analytics onErrorOccurredError happens Custom error handling, retry logic
Example: Tool Permission Control const session = await client.createSession ({
hooks : {
onPreToolUse : async (input) => {
if (["shell" , "bash" ].includes (input.toolName )) {
return { permissionDecision : "deny" , permissionDecisionReason : "Shell access not permitted" };
}
return { permissionDecision : "allow" };
},
},
});
Pre-Tool Use Output Field Type Description permissionDecision"allow" | "deny" | "ask"Whether to allow the tool call permissionDecisionReasonstring Explanation for deny/ask modifiedArgsobject Modified arguments to pass additionalContextstring Extra context for conversation suppressOutputboolean Hide tool output from conversation
MCP Server Integration Connect to MCP servers for pre-built tool capabilities.
Remote HTTP Server const session = await client.createSession ({
mcpServers : {
github : { type : "http" , url : "https://api.githubcopilot.com/mcp/" },
},
});
Local Stdio Server const session = await client.createSession ({
mcpServers : {
filesystem : {
type : "local" ,
command : "npx" ,
args : ["-y" , "@modelcontextprotocol/server-filesystem" , "/allowed/path" ],
tools : ["*" ],
},
},
});
MCP Config Fields Field Type Description type"local" | "http"Server transport type commandstring Executable path (local) argsstring[] Command arguments (local) urlstring Server URL (http) toolsstring[] ["*"] or specific tool namesenvobject Environment variables cwdstring Working directory (local) timeoutnumber Timeout in milliseconds
Authentication
Methods (Priority Order)
Explicit token — githubToken in constructorEnvironment variables — COPILOT_GITHUB_TOKEN → GH_TOKEN → GITHUB_TOKENStored OAuth — From copilot auth loginGitHub CLI — gh auth credentials
Programmatic Token const client = new CopilotClient ({ githubToken : process.env .GITHUB_TOKEN });
BYOK (Bring Your Own Key) Use your own API keys — no Copilot subscription required.
const session = await client.createSession ({
model : "gpt-5.2-codex" ,
provider : {
type : "openai" ,
baseUrl : "https://your-resource.openai.azure.com/openai/v1/" ,
wireApi : "responses" ,
apiKey : process.env .FOUNDRY_API_KEY ,
},
});
Provider Type Notes OpenAI "openai"OpenAI API and compatible endpoints Azure OpenAI "azure"Native Azure endpoints (don't include /openai/v1) Azure AI Foundry "openai"OpenAI-compatible Foundry endpoints Anthropic "anthropic"Claude models Ollama "openai"Local models, no API key needed
Wire API: Use "responses" for GPT-5 series, "completions" (default) for others.
Session Persistence Resume sessions across restarts by providing your own session ID.
const session = await client.createSession ({
sessionId : "user-123-task-456" ,
model : "gpt-4.1" ,
});
const resumed = await client.resumeSession ("user-123-task-456" );
await resumed.sendAndWait ({ prompt : "What did we discuss?" });
const sessions = await client.listSessions ();
await client.deleteSession ("user-123-task-456" );
await session.destroy ();
BYOK sessions: Must re-provide provider config on resume (keys are not persisted).
Infinite Sessions For long-running workflows that may exceed context limits:
const session = await client.createSession ({
infiniteSessions : {
enabled : true ,
backgroundCompactionThreshold : 0.80 ,
bufferExhaustionThreshold : 0.95 ,
},
});
Custom Agents Define specialized AI personas:
const session = await client.createSession ({
customAgents : [{
name : "pr-reviewer" ,
displayName : "PR Reviewer" ,
description : "Reviews pull requests for best practices" ,
prompt : "You are an expert code reviewer. Focus on security, performance, and maintainability." ,
}],
});
System Message Control AI behavior and personality:
const session = await client.createSession ({
systemMessage : { content : "You are a helpful assistant. Always be concise." },
});
Skills Integration Load skill directories to extend Copilot's capabilities:
const session = await client.createSession ({
skillDirectories : ["./skills/code-review" , "./skills/documentation" ],
disabledSkills : ["experimental-feature" ],
});
Permission & Input Handlers Handle tool permissions and user input requests programmatically:
const session = await client.createSession ({
onPermissionRequest : async (request) => {
if (request.kind === "shell" ) {
return { approved : request.command .startsWith ("git" ) };
}
return { approved : true };
},
onUserInputRequest : async (request) => {
return { response : "yes" };
},
});
External CLI Server Connect to a separately running CLI instead of auto-managing the process:
copilot --headless --port 4321
const client = new CopilotClient ({ cliUrl : "localhost:4321" });
Client Configuration Option Type Description cliPathstring Path to Copilot CLI executable cliUrlstring URL of external CLI server githubTokenstring GitHub token for auth useLoggedInUserboolean Use stored CLI credentials (default: true) logLevelstring "none" | "error" | "warning" | "info" | "debug"autoRestartboolean Auto-restart CLI on crash (default: true) useStdioboolean Use stdio transport (default: true)
Session Configuration Option Type Description modelstring Model to use (e.g., "gpt-4.1") sessionIdstring Custom ID for resumable sessions streamingboolean Enable streaming responses toolsTool[] Custom tools mcpServersobject MCP server configurations hooksobject Session hooks providerobject BYOK provider config customAgentsobject[] Custom agent definitions systemMessageobject System message override skillDirectoriesstring[] Directories to load skills from disabledSkillsstring[] Skills to disable reasoningEffortstring Reasoning effort level availableToolsstring[] Restrict available tools excludedToolsstring[] Exclude specific tools infiniteSessionsobject Auto-compaction config workingDirectorystring Working directory
Debugging Enable debug logging to troubleshoot issues:
const client = new CopilotClient ({ logLevel : "debug" });
CLI not found → Install CLI or set cliPathNot authenticated → Run copilot auth login or provide githubTokenSession not found → Don't use session after destroy()Connection refused → Check CLI process, enable autoRestart
Key API Summary Language Client Session Create Send Stop Node.js new CopilotClient()client.createSession()session.sendAndWait()client.stop()Python CopilotClient()client.create_session()session.send_and_wait()client.stop()Go copilot.NewClient(nil)client.CreateSession()session.SendAndWait()client.Stop().NET new CopilotClient()client.CreateSessionAsync()session.SendAndWaitAsync()client.DisposeAsync()
References
When to Use This skill is applicable to execute the workflow or actions described in the overview.
Connections
Domain: [[Software Entwicklung]]Kategorie: [[Entwickler-Tools]]Navigation: [[Skills Uebersicht]], [[Home]] 