copilot-sdk

Build applications powered by GitHub Copilot using the Copilot SDK — session management, custom tools, streaming, hooks, MCP servers, BYOK, deployment patterns

跳到安装

仓库: fabioc-aloha/Alex_Plug_In
最近来源活动: 2026年4月14日 22:14
检测到的 SKILL.md 语言: 英语
星标: 5
分支: 3

安装方式

默认使用会先检查来源的 Prompt；你也可以切换为直接命令，或下载本地副本。

用 Codex 或 Claude 帮你安装复制这段 Prompt，粘贴到 Codex、Claude 或其他助手里，让它检查 Skill 页面并帮你完成安装。

直接命令不会经过审查 Prompt；运行前请先检查来源。

npx skills add https://github.com/fabioc-aloha/Alex_Plug_In --skill copilot-sdk

命令会保持在同一行。复制前请横向滚动并检查完整内容。

想先保存到本地？可下载 SkillsMP 当前能够提供的文件。

检查来源文件

决定是否安装前，请先阅读 SKILL.md，以及 SkillsMP 当前展示的配套文件。

SKILL.md

来源说明 · 只读预览

返回搜索返回安装

ascii-project-dashboard

Create and maintain ASCII visual dashboards for project tracking with parallel lane progress bars

2026-04-15

audio-memory

Store and manage voice samples for TTS cloning — portable, version-controlled audio references

2026-04-15

markdown-mermaid

Clear documentation through visual excellence

2026-04-15

查看这个仓库的全部 Skills

Your App → SDK Client → [stdio/TCP] → Copilot CLI → Model Provider
                                           ↕
                                      MCP Servers

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(response?.data.content);

await client.stop();

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

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)

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

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

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],
});

Hook	Trigger	Use Case
`onPreToolUse`	Before tool executes	Permission control, argument modification
`onPostToolUse`	After tool executes	Result transformation, logging, redaction
`onUserPromptSubmitted`	User sends message	Prompt modification, context injection
`onSessionStart`	Session begins	Add context, configure session
`onSessionEnd`	Session ends	Cleanup, analytics, metrics
`onErrorOccurred`	Error happens	Custom error handling, retry logic

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" };
        },
    },
});

hooks: {
    onPostToolUse: async (input) => {
        if (typeof input.toolResult === "string") {
            let redacted = input.toolResult;
            for (const pattern of SENSITIVE_PATTERNS) {
                redacted = redacted.replace(pattern, "[REDACTED]");
            }
            if (redacted !== input.toolResult) {
                return { modifiedResult: redacted };
            }
        }
        return null; // Pass through unchanged
    },
}

const session = await client.createSession({
    mcpServers: {
        filesystem: {
            type: "local",
            command: "npx",
            args: ["-y", "@modelcontextprotocol/server-filesystem", "/allowed/path"],
            tools: ["*"],
            env: { DEBUG: "true" },
            cwd: "./servers",
            timeout: 30000,
        },
    },
});

const session = await client.createSession({
    mcpServers: {
        github: {
            type: "http",
            url: "https://api.githubcopilot.com/mcp/",
            headers: { Authorization: "Bearer ${TOKEN}" },
            tools: ["*"],
        },
    },
});

# Test MCP server independently
npx @modelcontextprotocol/inspector /path/to/your/mcp-server

const client = new CopilotClient({
    githubToken: userAccessToken,    // gho_ or ghu_ token from OAuth flow
    useLoggedInUser: false,          // Don't use stored CLI credentials
});

provider: { type: "openai", baseUrl: "https://api.openai.com/v1", apiKey: process.env.OPENAI_API_KEY }

provider: {
    type: "openai",
    baseUrl: "https://your-resource.openai.azure.com/openai/v1/",
    apiKey: process.env.FOUNDRY_API_KEY,
    wireApi: "responses",  // Use "responses" for GPT-5 series
}

provider: {
    type: "azure",
    baseUrl: "https://my-resource.openai.azure.com",
    apiKey: process.env.AZURE_OPENAI_KEY,
    azure: { apiVersion: "2024-10-21" },
}

provider: { type: "anthropic", baseUrl: "https://api.anthropic.com", apiKey: process.env.ANTHROPIC_API_KEY }

provider: { type: "openai", baseUrl: "http://localhost:11434/v1" }

// Create with explicit ID
const session = await client.createSession({
    sessionId: "user-123-task-456",
    model: "gpt-4.1",
});

// Resume later (even from a different client instance)
const resumed = await client.resumeSession("user-123-task-456");
await resumed.sendAndWait({ prompt: "What did we discuss?" });

Pattern	Example	Use Case
`user-{userId}-{taskId}`	`user-alice-pr-review-42`	Multi-user apps
`tenant-{tenantId}-{workflow}`	`tenant-acme-onboarding`	Multi-tenant SaaS
`{userId}-{taskType}-{timestamp}`	`alice-deploy-1706932800`	Time-based cleanup

Data	Persisted?	Notes
Conversation history	✅ Yes	Full message thread
Tool call results	✅ Yes	Cached for context
Agent planning state	✅ Yes	`plan.md` file
Provider/API keys	❌ No	Must re-provide on resume
In-memory tool state	❌ No	Design tools to be stateless

const session = await client.createSession({
    infiniteSessions: {
        enabled: true,
        backgroundCompactionThreshold: 0.80,  // Start background compaction at 80%
        bufferExhaustionThreshold: 0.95,      // Block and compact at 95%
    },
});

const client = new CopilotClient(); // Auto-manages CLI process

copilot --headless --port 4321

const client = new CopilotClient({ cliUrl: "localhost:4321" });

services:
  copilot-cli:
    image: ghcr.io/github/copilot-cli:latest
    command: ["--headless", "--port", "4321"]
    environment:
      - COPILOT_GITHUB_TOKEN=${COPILOT_GITHUB_TOKEN}
    volumes:
      - session-data:/root/.copilot/session-state
  api:
    build: .
    environment:
      - CLI_URL=copilot-cli:4321
    depends_on: [copilot-cli]
volumes:
  session-data:

Option	Type	Default	Description
`cliPath`	string	Auto-detected	Path to Copilot CLI executable
`cliUrl`	string	—	URL of external CLI server
`githubToken`	string	—	GitHub token for auth
`useLoggedInUser`	boolean	`true`	Use stored CLI credentials
`logLevel`	string	`"none"`	`"none"` \| `"error"` \| `"warning"` \| `"info"` \| `"debug"`
`autoRestart`	boolean	`true`	Auto-restart CLI on crash

Option	Type	Description
`model`	string	Model to use (e.g., `"gpt-4.1"`, `"claude-sonnet-4"`)
`sessionId`	string	Custom ID for resumable sessions
`streaming`	boolean	Enable streaming responses
`tools`	Tool[]	Custom tools
`mcpServers`	object	MCP server configurations
`hooks`	object	Session hooks
`provider`	object	BYOK provider config
`customAgents`	object[]	Custom agent definitions
`systemMessage`	object	System message override
`skillDirectories`	string[]	Directories to load skills from
`infiniteSessions`	object	Auto-compaction config

Language	Client	Session Create	Send	Resume	Stop
Node.js	`new CopilotClient()`	`client.createSession()`	`session.sendAndWait()`	`client.resumeSession()`	`client.stop()`
Python	`CopilotClient()`	`client.create_session()`	`session.send_and_wait()`	`client.resume_session()`	`client.stop()`
Go	`copilot.NewClient(nil)`	`client.CreateSession()`	`session.SendAndWait()`	`client.ResumeSession()`	`client.Stop()`
.NET	`new CopilotClient()`	`client.CreateSessionAsync()`	`session.SendAndWaitAsync()`	`client.ResumeSessionAsync()`	`client.DisposeAsync()`

Language	Package	Install
Node.js	`@github/copilot-sdk`	`npm install @github/copilot-sdk`
Python	`github-copilot-sdk`	`pip install github-copilot-sdk`
Go

Language	Package	Install
Node.js	`@github/copilot-sdk`	`npm install @github/copilot-sdk`
Python	`github-copilot-sdk`	`pip install github-copilot-sdk`
Go

Mode	Description	Use Case
Stdio (default)	CLI as subprocess via pipes	Local dev, single process
TCP	CLI as network server	Multi-client, backend services

Pattern	Isolation	Resources	Best For
CLI per user	Complete	High	Multi-tenant SaaS, compliance
Shared CLI + session IDs	Logical	Low	Internal tools
Shared sessions	None	Low	Team collaboration (requires locking)

name	copilot-sdk
description	Build applications powered by GitHub Copilot using the Copilot SDK — session management, custom tools, streaming, hooks, MCP servers, BYOK, deployment patterns
tier	standard
applyTo	*/copilot,*/copilot-sdk,/github-copilot*

copilot-sdk

来源信息

安装方式

检查来源文件

同仓库更多 Skills

GitHub Copilot SDK

Prerequisites

Installation

同仓库更多 Skills

GitHub Copilot SDK

Prerequisites

Installation

Architecture

Core Pattern: Client → Session → Message

Node.js / TypeScript

Python

Go

.NET

Streaming Responses

Custom Tools

Tool Requirements

Hooks

Pre-Tool Use Hook

Post-Tool Use Hook (Redaction)

MCP Server Integration

Local Stdio Server

Remote HTTP Server

MCP Debugging

Authentication

Methods (Priority Order)

OAuth GitHub App

BYOK (Bring Your Own Key)

Provider Configurations

BYOK Limitations

Session Persistence

Session ID Best Practices

What Gets Persisted

Infinite Sessions

Deployment Patterns

Local CLI (Default)

External CLI Server (Backend Services)

Docker Compose

Session Isolation Patterns

Production Checklist

Configuration Reference

Client Configuration

Session Configuration

API Summary

References