GitHub Copilot Provider

기준일: 2026-07-26
난이도: 중급
공식 기준: GitHub Copilot

개요

이 페이지는 OpenClaw GitHub Copilot provider의 인증, 모델 ref, 온보딩 플래그, 설정 키를 공식 문서 기준으로 정리합니다.

공식 요약: Sign in to GitHub Copilot from OpenClaw using the device flow or non-interactive token import

model ref는 보통 provider/model 형식입니다. API key·endpoint·model id는 아래 원문 값을 그대로 쓰세요. 임의로 키나 엔드포인트를 만들지 마세요.

빠른 참조

Command	Flag	Description
openclaw models auth login-github-copilot	--yes	Overwrite an existing auth profile without prompting
openclaw models auth login --provider github-copilot --method device	--set-default	Also apply the provider's recommended default model

공식 문서 기반 상세

아래는 공식 providers/github-copilot 문서를 Mintlify 컴포넌트만 정리하고 공통 제목을 한국어로 맞춘 내용입니다. 설정 키, env, model ref, CLI 플래그는 원문 그대로 유지합니다.

GitHub Copilot is GitHub's AI coding assistant. It provides access to Copilot models for your GitHub account and plan. OpenClaw can use Copilot as a model provider or agent runtime in three different ways.

Three ways to use Copilot in OpenClaw

Use the native device-login flow to obtain a GitHub token, then exchange it for
Copilot API tokens when OpenClaw runs. This is the **default** and simplest path
because it does not require VS Code.


  

Run the login command

    ```bash
    openclaw models auth login-github-copilot
    ```

    You will be prompted to visit a URL and enter a one-time code. Keep the
    terminal open until it completes.
  

  

Set a default model

    ```bash
    openclaw models set github-copilot/claude-opus-4.7
    ```

    Or in config:

    ```json5
    {
      agents: {
        defaults: { model: { primary: "github-copilot/claude-opus-4.7" } },
      },
    }
    ```
  






Install the external `@openclaw/copilot` plugin when you want GitHub's
Copilot CLI and SDK to own the low-level agent loop for selected
`github-copilot/*` models.

```bash
openclaw plugins install @openclaw/copilot
```

Then opt a model or provider into the runtime:

```json5
{
  agents: {
    defaults: {
      model: "github-copilot/gpt-5.5",
      models: {
        "github-copilot/gpt-5.5": {
          agentRuntime: { id: "copilot" },
        },
      },
    },
  },
}
```

Choose this when you want native Copilot CLI sessions, SDK-managed thread
state, and Copilot-owned compaction for those agent turns. Without the
explicit `agentRuntime` opt-in, `github-copilot/*` models keep using the
built-in provider. See [Copilot SDK harness](https://docs.openclaw.ai/plugins/copilot) for the full
runtime contract.




Use the **Copilot Proxy** VS Code extension as a local bridge. OpenClaw talks to
the proxy's `/v1` endpoint (default `http://localhost:3000/v1`) and uses the
model list you configure.

The `copilot-proxy` plugin ships with OpenClaw and is enabled by default.
Configure the base URL and model ids with:

```bash
openclaw models auth login --provider copilot-proxy --set-default
```

Choose this when you already run Copilot Proxy in VS Code or need to route through it. The VS Code extension must stay running.

GitHub Enterprise (data residency)

If your organization uses a data-residency GitHub Enterprise tenant (a *.ghe.com host such as your-org.ghe.com), Copilot lives on tenant-local endpoints rather than public github.com. OpenClaw exposes this as a first-class auth choice so you do not have to hand-edit URLs.

Pick the Enterprise auth choice

In onboarding or `openclaw models auth`, choose
**GitHub Copilot (Enterprise / data residency)**. You will be prompted for
your Enterprise domain (for example `your-org.ghe.com`), then the device
login runs against that tenant.

Enter the tenant root only (`your-org.ghe.com`). Derived service hosts such
as `api.your-org.ghe.com` or `copilot-api.your-org.ghe.com` are not accepted;
OpenClaw derives those endpoints from the tenant root automatically.

```bash
openclaw models auth login --provider github-copilot --method device-enterprise
```

Domain is persisted to config

The chosen host is stored under the provider params so later token refreshes
and completions target the tenant automatically:

```json5
{
  models: {
    providers: {
      "github-copilot": { params: { githubDomain: "your-org.ghe.com" } },
    },
  },
}
```

The device flow, token exchange, and completions resolve to https://your-org.ghe.com/login/device/code, https://api.your-org.ghe.com/copilot_internal/v2/token, and https://copilot-api.your-org.ghe.com respectively. Data-residency tokens carry a tenant stamp and no proxy hint, so the completions base URL falls back to the tenant Copilot host instead of the public endpoint.

Switching domains always re-runs the device login. If you already have a stored Copilot token and pick a different domain (public github.com ↔ a *.ghe.com tenant, or one tenant to another), OpenClaw will not reuse the existing token — it forces a fresh login so the token is scoped to the domain being written to config. Re-running login for the same domain still offers to reuse the current token. Switching back to public github.com clears the persisted githubDomain so config returns to the default.

The COPILOT_GITHUB_DOMAIN environment variable overrides the resolved domain for every Copilot path that resolves it — the Enterprise device login (--method device-enterprise), the standalone openclaw models auth login-github-copilot shortcut, token refresh, embeddings, and completions. Set it to your *.ghe.com host for fully headless or CI setups. Leave it unset (and the config param absent) to use public github.com. Logins persist the domain they minted the token for (and clear it when logging in against public github.com), so routing stays correct even after the environment variable is unset.

Optional flags

Command	Flag	Description
openclaw models auth login-github-copilot	--yes	Overwrite an existing auth profile without prompting
openclaw models auth login --provider github-copilot --method device	--set-default	Also apply the provider's recommended default model

# Skip the re-login confirmation
openclaw models auth login-github-copilot --yes

# Login and set the default model in one step
openclaw models auth login --provider github-copilot --method device --set-default

Non-interactive onboarding

The device-login flow requires an interactive TTY. For headless setup, import an existing GitHub OAuth access token with openclaw onboard --non-interactive:

openclaw onboard --non-interactive --accept-risk \
  --auth-choice github-copilot \
  --github-copilot-token "$COPILOT_GITHUB_TOKEN" \
  --skip-channels --skip-health

You can also omit --auth-choice; passing --github-copilot-token infers the GitHub Copilot provider auth choice. If the flag is omitted, onboarding falls back to COPILOT_GITHUB_TOKEN, GH_TOKEN, then GITHUB_TOKEN. Use --secret-input-mode ref with COPILOT_GITHUB_TOKEN set to store an env-backed tokenRef instead of plaintext in auth-profiles.json.

Interactive TTY required

The device-login flow requires an interactive TTY. Run it directly in a
terminal, not in a non-interactive script or CI pipeline.

Model availability depends on your plan

Copilot model availability depends on your GitHub plan. If a model is
rejected, try another ID (for example `github-copilot/gpt-5.5`). See
GitHub's [supported models per Copilot plan](https://docs.github.com/en/copilot/reference/ai-models/supported-models#supported-ai-models-per-copilot-plan)
for the current model list.

Live catalog refresh from the Copilot API

Once the device-login (or env-var) auth path has resolved a GitHub token,
OpenClaw refreshes the model catalog on demand from `${baseUrl}/models`
(the same endpoint VS Code Copilot uses) so the runtime tracks
per-account entitlement and accurate context windows without manifest
churn. Newly published Copilot models become visible without an OpenClaw
upgrade, and context windows reflect the real per-model limits
(e.g. 400k for the gpt-5.x series, 1M for the internal
`claude-opus-*-1m` variants).

The bundled static catalog stays as the visible fallback when discovery
is disabled, the user has no GitHub auth profile, the token-exchange
fails, or the `/models` HTTPS call errors. To opt out and rely entirely
on the static manifest catalog (offline / air-gapped scenarios):

```json5
{
  plugins: {
    entries: {
      "github-copilot": {
        config: { discovery: { enabled: false } },
      },
    },
  },
}
```

Transport selection

Claude model IDs use the Anthropic Messages transport automatically.
Gemini models use the OpenAI Chat Completions transport; GPT and o-series
models keep the OpenAI Responses transport. OpenClaw selects the correct
transport based on the model ref.

Request compatibility

OpenClaw sends Copilot IDE-style request headers on Copilot transports
(VS Code editor/plugin versions and the `vscode-chat` integration id),
marks tool-result follow-up turns as agent-initiated, and sets the Copilot
vision header when a turn carries image input.

Environment variable resolution order

OpenClaw resolves Copilot auth from environment variables in the following
priority order:

| Priority | Variable              | Notes                            |
| -------- | --------------------- | -------------------------------- |
| 1        | `COPILOT_GITHUB_TOKEN` | Highest priority, Copilot-specific |
| 2        | `GH_TOKEN`            | GitHub CLI token (fallback)      |
| 3        | `GITHUB_TOKEN`        | Standard GitHub token (lowest)   |

When multiple variables are set, OpenClaw uses the highest-priority one.
The device-login flow (`openclaw models auth login-github-copilot`) stores
its token in the auth profile store and takes precedence over all environment
variables.

Token storage

The login stores a GitHub token in the auth profile store (profile id
`github-copilot:github`) and exchanges it for a short-lived Copilot API
token when OpenClaw runs. You do not need to manage the token manually.

Memory search embeddings

GitHub Copilot can also serve as an embedding provider for memory search. If you have a Copilot subscription and have logged in, OpenClaw can use it for embeddings without a separate API key.

Config

Set memory.search.provider explicitly to use GitHub Copilot embeddings. If a GitHub token is available, OpenClaw discovers available embedding models from the Copilot API and picks the best one automatically.

{
  memory: {
    search: {
      provider: "github-copilot",
      // Optional: override the auto-discovered model
      model: "text-embedding-3-small",
    },
  },
}

동작 방식

1. OpenClaw resolves your GitHub token (from env vars or auth profile).
2. Exchanges it for a short-lived Copilot API token.
3. Queries the Copilot /models endpoint to discover available embedding models.
4. Picks the best model (preference order: text-embedding-3-small, text-embedding-3-large, text-embedding-ada-002).
5. Sends embedding requests to the Copilot /embeddings endpoint.

Model availability depends on your GitHub plan. If no embedding models are available, OpenClaw skips Copilot and tries the next provider.

관련 문서

Choosing providers, model refs, and failover behavior.


Auth details and credential reuse rules.

검증 체크리스트

• openclaw models list --provider github-copilot 로 모델이 보이는지 확인
• 기본 model alias를 agents.defaults.model.primary에 설정했는지 확인
• API key / OAuth / 로컬 런타임 인증 경로를 공식 문서와 대조했는지 확인
• failover 시 데이터가 다른 provider로 이동할 수 있는지 검토

관련

• Provider 목록 인덱스
• 로컬 모델과 Provider
• 공식: Provider directory, Model providers