@nick3/copilot-api 1.2.4 → 1.3.1

package/README.md

@@ -23,7 +23,8 @@ English | [中文](./README_CN.md)
 
 ---
 
-**Note:** If you are using [opencode](https://github.com/sst/opencode), you do not need this project. Opencode supports GitHub Copilot provider out of the box.
+> [!NOTE]
+> [opencode](https://github.com/sst/opencode) already ships with a built-in GitHub Copilot provider, so you may not need this project for basic usage. This proxy is still useful if you want OpenCode to talk to Copilot through `@ai-sdk/anthropic`, preserve Anthropic Messages semantics for tool use, prefer the native Messages API over plain Chat Completions for Claude-family models, use `gpt-5.4` phase-aware commentary, or fine-tune premium-request usage with small-model fallbacks.
 
 ---
 
@@ -31,9 +32,17 @@ English | [中文](./README_CN.md)
 
 A reverse-engineered proxy for the GitHub Copilot API that exposes it as an OpenAI and Anthropic compatible service. This allows you to use GitHub Copilot with any tool that supports the OpenAI Chat Completions API or the Anthropic Messages API, including to power [Claude Code](https://docs.anthropic.com/en/docs/claude-code/overview).
 
+Compared with routing everything through plain Chat Completions compatibility, this proxy can prefer Copilot's native Anthropic-style Messages API for Claude-family models, preserve more native thinking/tool semantics, reduce unnecessary Premium request consumption on warmup or resumed tool turns, and expose phase-aware `gpt-5.4` / `gpt-5.3-codex` responses that are easier for users to follow.
+
 ## Features
 
 - **OpenAI & Anthropic Compatibility**: Exposes GitHub Copilot as an OpenAI-compatible (`/v1/responses`, `/v1/chat/completions`, `/v1/models`, `/v1/embeddings`) and Anthropic-compatible (`/v1/messages`) API.
+- **Anthropic-First Routing for Claude Models**: When a model supports Copilot's native `/v1/messages` endpoint, the proxy prefers it over `/responses` or `/chat/completions`, preserving Anthropic-style `tool_use` / `tool_result` flows and more Claude-native behavior.
+- **Fewer Unnecessary Premium Requests**: Reduces wasted premium usage by routing warmup and compact/background requests to `smallModel`, merging `tool_result` follow-ups back into the tool flow, and treating resumed tool turns as continuation traffic instead of fresh premium interactions.
+- **Phase-Aware `gpt-5.4` and `gpt-5.3-codex`**: These models can emit user-friendly commentary before deeper reasoning or tool use, so long-running coding actions are easier to understand instead of appearing as a sudden tool burst.
+- **Claude Native Beta Support**: On the Messages API path, supports Anthropic-native capabilities such as `interleaved-thinking`, `advanced-tool-use`, and `context-management`, which are difficult or unavailable through plain Chat Completions compatibility.
+- **Subagent Marker Integration**: Optional Claude Code and opencode plugins can inject `__SUBAGENT_MARKER__...` and propagate `x-session-id` so subagent traffic keeps the correct root session and agent/user semantics.
+- **OpenCode via `@ai-sdk/anthropic`**: Point OpenCode at this proxy as an Anthropic provider so Anthropic Messages semantics, premium-request optimizations, and Claude-native behavior are preserved end to end.
 - **Claude Code Integration**: Easily configure and launch [Claude Code](https://docs.anthropic.com/en/docs/claude-code/overview) to use Copilot as its backend with a simple command-line flag (`--claude-code`).
 - **Usage Dashboard**: A web-based dashboard to monitor your Copilot API usage, view quotas, and see detailed statistics.
 - **Admin UI**: Modern admin console (`/admin`) to inspect account runtime status and request history, with rich filtering and a request-detail JSON viewer (search/copy/download). Includes theme (system/light/dark) and motion (magic/subtle/off) toggles.
@@ -43,6 +52,49 @@ A reverse-engineered proxy for the GitHub Copilot API that exposes it as an Open
 - **Flexible Authentication**: Authenticate interactively or provide a GitHub token directly, suitable for CI/CD environments.
 - **Support for Different Account Types**: Works with individual, business, and enterprise GitHub Copilot plans.
 - **Multi-Account Support**: Use multiple GitHub Copilot accounts with automatic routing: premium models use accounts in order and fall back on quota exhaustion; free models are distributed round-robin across accounts by default (configurable in config.json).
+- **Opencode OAuth Support**: Use opencode GitHub Copilot authentication by setting `COPILOT_API_OAUTH_APP=opencode` environment variable.
+- **GitHub Enterprise Support**: Connect to GHE.com by setting `COPILOT_API_ENTERPRISE_URL` environment variable (e.g., `company.ghe.com`).
+- **Custom Data Directory**: Change the default data directory (where tokens and config are stored) by setting `COPILOT_API_HOME` environment variable.
+- **Multi-Provider Anthropic Proxy Routes**: Add global provider configs and call external Anthropic-compatible APIs via `/:provider/v1/messages` and `/:provider/v1/models`.
+
+## Better Agent Semantics
+
+### Native Anthropic Messages API when available
+
+For models that advertise Copilot support for `/v1/messages`, this project sends the request to the native Messages API first and only falls back to `/responses` or `/chat/completions` when needed.
+
+Compared with using Claude-family models only through Chat Completions compatibility, the Messages API path keeps more Anthropic-native behavior, including support for:
+
+- `interleaved-thinking-2025-05-14`
+- `advanced-tool-use-2025-11-20`
+- `context-management-2025-06-27`
+
+Supported `anthropic-beta` values are filtered and forwarded on the native Messages path, and `interleaved-thinking` is added automatically when a thinking budget is requested for non-adaptive extended thinking.
+
+### Fewer unnecessary Premium requests
+
+The proxy includes request-accounting safeguards designed for tool-heavy coding workflows:
+
+- tool-less warmup or probe requests can be forced onto `smallModel` so background checks do not spend premium usage;
+- compact/background requests can be downgraded to `smallModel` automatically;
+- mixed `tool_result` + reminder text blocks are merged back into the `tool_result` flow instead of being counted like fresh user turns;
+- `x-initiator` is derived from the latest message or item, not stale assistant history.
+
+This helps resumed tool turns continue the existing workflow instead of consuming an extra Premium request as a brand-new interaction.
+
+### Phase-aware `gpt-5.4` and `gpt-5.3-codex`
+
+By default, the built-in `extraPrompts` for `gpt-5.4` and `gpt-5.3-codex` enable intermediary-update behavior, and the proxy translates assistant turns into `phase: "commentary"` before tool calls and `phase: "final_answer"` for the final response.
+
+That gives clients a short, user-friendly explanation of what the model is about to do before deeper reasoning or tool execution begins.
+
+### Subagent marker integration
+
+For subagent-based clients, this project can preserve root session context and correctly classify subagent-originated traffic.
+
+The marker flow uses `__SUBAGENT_MARKER__...` inside a `<system-reminder>` block together with root `x-session-id` propagation. When a marker is detected, the proxy can keep the parent session identity, infer `x-initiator: agent`, and tag the interaction as subagent traffic instead of a fresh top-level request.
+
+Optional marker producers are included for both Claude Code and opencode; see [Subagent Marker Integration](#subagent-marker-integration-optional) below for setup details.
 
 ## Demo
 
@@ -245,14 +297,32 @@ The `<target>` can be either the account ID (GitHub username) or a 1-based index
     "auth": {
       "apiKeys": []
     },
+    "providers": {
+      "custom": {
+        "type": "anthropic",
+        "enabled": true,
+        "baseUrl": "your-base-url",
+        "apiKey": "sk-your-provider-key",
+        "models": {
+          "kimi-k2.5": {
+            "temperature": 1,
+            "topP": 0.95
+          }
+        }
+      }
+    },
     "extraPrompts": {
       "gpt-5-mini": "<built-in exploration prompt>",
-      "gpt-5.1-codex-max": "<built-in exploration prompt>"
-    },
-    "smallModel": "gpt-5-mini",
-    "freeModelLoadBalancing": true,
-    "modelReasoningEfforts": {
-      "gpt-5-mini": "low"
+      "gpt-5.3-codex": "<built-in commentary prompt>",
+      "gpt-5.4": "<built-in commentary prompt>"
+	    },
+	    "smallModel": "gpt-5-mini",
+	    "freeModelLoadBalancing": true,
+	    "responsesApiContextManagementModels": [],
+	    "modelReasoningEfforts": {
+	      "gpt-5-mini": "low",
+	      "gpt-5.3-codex": "xhigh",
+	      "gpt-5.4": "xhigh"
     },
     "modelAliases": {
       "fast": { "target": "gpt-5-mini", "allowOriginal": false },
@@ -265,13 +335,22 @@ The `<target>` can be either the account ID (GitHub username) or a 1-based index
   }
   ```
 - **auth.apiKeys:** API keys used for request authentication. Supports multiple keys for rotation. Requests can authenticate with either `x-api-key: <key>` or `Authorization: Bearer <key>`. If empty or omitted, authentication is disabled.
-- **extraPrompts:** Map of `model -> prompt` appended to the first system prompt when translating Anthropic-style requests to Copilot. Use this to inject guardrails or guidance per model. Missing default entries are auto-added without overwriting your custom prompts.
-- **smallModel:** Fallback model used for tool-less warmup messages (e.g., Claude Code probe requests) to avoid spending premium requests; defaults to `gpt-5-mini`. If original names are blocked and this points to an aliased target, it resolves to the first alias.
-- **freeModelLoadBalancing:** Enable round-robin routing for free-model requests across multiple accounts. Defaults to `true`. Set to `false` to route free-model requests sequentially (same ordering strategy as premium models).
-- **apiKey (deprecated):** Legacy single-key field kept for migration compatibility. Prefer `auth.apiKeys`. When `auth.apiKeys` is empty, the server falls back to `COPILOT_API_KEY` and then `apiKey`.
-- **modelReasoningEfforts:** Per-model `reasoning.effort` sent to the Copilot Responses API. Allowed values are `none`, `minimal`, `low`, `medium`, `high`, and `xhigh`. If a model isn’t listed, `high` is used by default.
-- **modelAliases:** Map of `alias -> { target, allowOriginal? }` (legacy string values are still accepted). Alias keys are normalized (trim + lowercase) and must be non-empty; aliases cannot map to themselves (case-insensitive), and conflicting normalized aliases are rejected. `allowOriginal` overrides the global default per alias. If multiple aliases map to the same target, original names are allowed when any alias sets `allowOriginal: true` (allow-wins). Admin UI/API rejects blocked keys (`__proto__`, `constructor`, `prototype`). Aliases can be used in downstream requests.
-- **allowOriginalModelNamesForAliases:** Global default for aliases that omit `allowOriginal`. When `false` (default), targets are blocked unless an alias explicitly allows them; when `true`, targets are allowed unless all aliases explicitly block them.
+	- **extraPrompts:** Map of `model -> prompt` appended to the first system prompt when translating Anthropic-style requests to Copilot. Use this to inject guardrails or guidance per model. Missing default entries are auto-added without overwriting your custom prompts. The built-in prompts for `gpt-5.3-codex` and `gpt-5.4` enable phase-aware commentary, which lets the model emit a short user-facing progress update before tools or deeper reasoning.
+	- **providers:** Global upstream provider map. Each provider key (for example `custom`) becomes a route prefix (`/custom/v1/messages`). Currently only `type: "anthropic"` is supported.
+	  - `enabled` defaults to `true` if omitted.
+	  - `baseUrl` should be provider API base URL without trailing `/v1/messages`.
+	  - `apiKey` is used as upstream `x-api-key`.
+	  - `models` (optional): Per-model configuration map. Each key is a model ID (matching the model name in requests), and the value is:
+	    - `temperature` (optional): Default temperature value used when the request does not specify one.
+	    - `topP` (optional): Default top_p value used when the request does not specify one.
+	    - `topK` (optional): Default top_k value used when the request does not specify one.
+	- **responsesApiContextManagementModels:** List of model IDs that should receive Responses API `context_management` compaction instructions. Use this when a model supports server-side context management and you want the proxy to keep only the latest compaction carrier on follow-up turns.
+	- **smallModel:** Fallback model used for tool-less warmup messages, compact/background requests, and other short housekeeping turns (for example from Claude Code or OpenCode) to avoid spending premium requests; defaults to `gpt-5-mini`. If original names are blocked and this points to an aliased target, it resolves to the preferred alias.
+	- **freeModelLoadBalancing:** Enable round-robin routing for free-model requests across multiple accounts. Defaults to `true`. Set to `false` to route free-model requests sequentially (same ordering strategy as premium models).
+	- **apiKey (deprecated):** Legacy single-key field kept for migration compatibility. Prefer `auth.apiKeys`. When `auth.apiKeys` is empty, the server falls back to `COPILOT_API_KEY` and then `apiKey`.
+	- **modelReasoningEfforts:** Per-model `reasoning.effort` sent to the Copilot Responses API. Allowed values are `none`, `minimal`, `low`, `medium`, `high`, and `xhigh`. If a model isn’t listed, `high` is used by default.
+	- **modelAliases:** Map of `alias -> { target, allowOriginal? }` (legacy string values are still accepted). Alias keys are normalized (trim + lowercase) and must be non-empty; aliases cannot map to themselves (case-insensitive), and conflicting normalized aliases are rejected. `allowOriginal` overrides the global default per alias. If multiple aliases map to the same target, original names are allowed when any alias sets `allowOriginal: true` (allow-wins). Admin UI/API rejects blocked keys (`__proto__`, `constructor`, `prototype`). Aliases can be used in downstream requests.
+	- **allowOriginalModelNamesForAliases:** Global default for aliases that omit `allowOriginal`. When `false` (default), targets are blocked unless an alias explicitly allows them; when `true`, targets are allowed unless all aliases explicitly block them.
 - **useFunctionApplyPatch:** When `true` (default), `POST /v1/responses` converts a `tools` entry with `{ "type": "custom", "name": "apply_patch" }` into an OpenAI-style `function` tool (with a parameter schema) for upstream compatibility. Set to `false` to leave custom tools untouched.
 - **forceAgent:** When `true`, `POST /v1/responses` treats a request as agent-initiated if **any** input item has `role: "assistant"`. When `false` (default), only the **last** input item is checked.
 - **compactUseSmallModel:** When `true`, detected "compact" requests (e.g., from Claude Code or opencode compact mode) will automatically use the configured `smallModel` to avoid consuming premium usage for short/background tasks. Defaults to `true`.
@@ -319,6 +398,9 @@ These endpoints are designed to be compatible with the Anthropic Messages API.
 | -------------------------------- | ------ | ------------------------------------------------------------ |
 | `POST /v1/messages`              | `POST` | Creates a model response for a given conversation.           |
 | `POST /v1/messages/count_tokens` | `POST` | Calculates the number of tokens for a given set of messages. |
+| `POST /:provider/v1/messages`       | `POST` | Proxies Anthropic Messages API to the configured provider.   |
+| `GET /:provider/v1/models`          | `GET`  | Proxies Anthropic Models API to the configured provider.     |
+| `POST /:provider/v1/messages/count_tokens` | `POST` | Calculates tokens locally for provider route requests. |
 
 ### Usage Monitoring Endpoints
 
@@ -445,8 +527,122 @@ npx @nick3/copilot-api@latest debug --json
 
 # Initialize proxy from environment variables (HTTP_PROXY, HTTPS_PROXY, etc.)
 npx @nick3/copilot-api@latest start --proxy-env
+
+# Use opencode GitHub Copilot authentication
+COPILOT_API_OAUTH_APP=opencode npx @nick3/copilot-api@latest start
+```
+
+### Opencode OAuth Authentication
+
+You can use opencode GitHub Copilot authentication instead of the default one:
+
+```sh
+# Set environment variable before running any command
+export COPILOT_API_OAUTH_APP=opencode
+
+# Then run start or auth commands
+npx @nick3/copilot-api@latest start
+npx @nick3/copilot-api@latest auth
+```
+
+Or use inline environment variable:
+
+```sh
+COPILOT_API_OAUTH_APP=opencode npx @nick3/copilot-api@latest start
+```
+
+## Using with OpenCode
+
+OpenCode already has a direct GitHub Copilot provider. Use this section when you want OpenCode to point at this proxy through `@ai-sdk/anthropic` and reuse the agent behaviors described earlier in this README.
+
+### Minimal setup
+
+Start the proxy with the OpenCode OAuth app:
+
+```sh
+COPILOT_API_OAUTH_APP=opencode npx @nick3/copilot-api@latest start
 ```
 
+Then point OpenCode at the proxy with `@ai-sdk/anthropic`.
+
+Example `~/.config/opencode/opencode.json`:
+
+```json
+{
+  "$schema": "https://opencode.ai/config.json",
+  "model": "local/gpt-5.4",
+  "small_model": "local/gpt-5-mini",
+  "agent": {
+    "build": {
+      "model": "local/gpt-5.4"
+    },
+    "plan": {
+      "model": "local/gpt-5.4"
+    },
+    "explore": {
+      "model": "local/gpt-5-mini"
+    }
+  },
+  "provider": {
+    "local": {
+      "npm": "@ai-sdk/anthropic",
+      "name": "Copilot API Proxy",
+      "options": {
+        "baseURL": "http://localhost:4141/v1",
+        "apiKey": "dummy"
+      },
+      "models": {
+        "gpt-5.4": {
+          "name": "gpt-5.4",
+          "modalities": {
+            "input": ["text", "image"],
+            "output": ["text"]
+          },
+          "limit": {
+            "context": 272000,
+            "output": 128000
+          }
+        },
+        "gpt-5-mini": {
+          "name": "gpt-5-mini",
+          "limit": {
+            "context": 128000,
+            "output": 64000
+          }
+        },
+        "claude-sonnet-4.6": {
+          "id": "claude-sonnet-4.6",
+          "name": "claude-sonnet-4.6",
+          "modalities": {
+            "input": ["text", "image"],
+            "output": ["text"]
+          },          
+          "limit": {
+            "context": 128000,
+            "output": 32000
+          },
+          "options": {
+            "thinking": {
+              "type": "enabled",
+              "budgetTokens": 31999
+            }
+          }
+        }
+      }
+    }
+  }
+}
+```
+
+Why these fields matter:
+
+- `npm: "@ai-sdk/anthropic"` is the important part. OpenCode will speak Anthropic Messages semantics to this proxy instead of flattening everything into OpenAI Chat Completions.
+- `options.baseURL` should be `http://localhost:4141/v1`; the Anthropic SDK will append `/messages`, `/models`, and `/messages/count_tokens` automatically.
+- `model`, `small_model`, and `agent.*.model` let you keep `gpt-5.4` for build/plan work while routing exploration and background work to `gpt-5-mini`.
+- If you enable `auth.apiKeys` in this proxy, replace `dummy` with a real key. Otherwise any placeholder value is fine.
+
+## Using the Usage Viewer
+
 ### Admin API examples
 
 ```sh
@@ -544,8 +740,8 @@ Here is an example `.claude/settings.json` file:
   "env": {
     "ANTHROPIC_BASE_URL": "http://localhost:4141",
     "ANTHROPIC_AUTH_TOKEN": "dummy",
-    "ANTHROPIC_MODEL": "gpt-5.2",
-    "ANTHROPIC_DEFAULT_SONNET_MODEL": "gpt-5.2",
+    "ANTHROPIC_MODEL": "gpt-5.4",
+    "ANTHROPIC_DEFAULT_SONNET_MODEL": "gpt-5.4",
     "ANTHROPIC_DEFAULT_HAIKU_MODEL": "gpt-5-mini",
     "DISABLE_NON_ESSENTIAL_MODEL_CALLS": "1",
     "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": "1",
@@ -561,20 +757,20 @@ Here is an example `.claude/settings.json` file:
 }
 ```
 
-### CLAUDE.md Recommended Content
+### CLAUDE.md / AGENTS.md (Optional)
 
-Please include the following in `CLAUDE.md` (for Claude usage):
+If you're using Claude Code (or another agent runner) and want stricter “ask before acting” behavior, you may choose to add rules like:
 
-- Prohibited from directly asking questions to users, MUST use AskUserQuestion tool.
-- Once you can confirm that the task is complete, MUST use AskUserQuestion tool to make user confirm. The user may respond with feedback if they are not satisfied with the result, which you can use to make improvements and try again.
+- Prefer using the runner's dedicated question tool for user-facing questions.
+- Ask the user to confirm completion before ending the task.
 
 You can find more options here: [Claude Code settings](https://docs.anthropic.com/en/docs/claude-code/settings#environment-variables)
 
 You can also read more about IDE integration here: [Add Claude Code to your IDE](https://docs.anthropic.com/en/docs/claude-code/ide-integrations)
 
-### Subagent Marker Integration (Optional)
+## Subagent Marker Integration (Optional)
 
-This project supports `x-initiator: agent` for subagent-originated requests.
+This project supports `x-initiator: agent` for subagent-originated requests and can preserve the root session identity with `x-session-id` when a subagent marker is present.
 
 #### Claude Code plugin producer (marketplace-based)
 

package/dist/{accounts-manager-eec8Wj3_.js → accounts-manager-BeKvbv0T.js}

@@ -7,9 +7,11 @@ import { createHash, randomUUID } from "node:crypto";
 import fs$1 from "node:fs";
 
 //#region src/lib/paths.ts
+const AUTH_APP = process.env.COPILOT_API_OAUTH_APP?.trim() || "";
+const ENTERPRISE_PREFIX = process.env.COPILOT_API_ENTERPRISE_URL ? "ent_" : "";
 const DEFAULT_DIR = path.join(os.homedir(), ".local", "share", "copilot-api");
 const APP_DIR = process.env.COPILOT_API_HOME || DEFAULT_DIR;
-const GITHUB_TOKEN_PATH = path.join(APP_DIR, "github_token");
+const GITHUB_TOKEN_PATH = path.join(APP_DIR, AUTH_APP, ENTERPRISE_PREFIX + "github_token");
 const CONFIG_PATH = path.join(APP_DIR, "config.json");
 const MODELS_PATH = path.join(APP_DIR, "models.json");
 const TOKENS_DIR = path.join(APP_DIR, "tokens");
@@ -32,6 +34,7 @@ function accountTokenPath(id) {
 }
 async function ensurePaths() {
 	await fs.mkdir(PATHS.APP_DIR, { recursive: true });
+	await fs.mkdir(path.join(PATHS.APP_DIR, AUTH_APP), { recursive: true });
 	await fs.mkdir(PATHS.TOKENS_DIR, { recursive: true });
 	await ensureFile(PATHS.GITHUB_TOKEN_PATH);
 	await ensureFile(PATHS.CONFIG_PATH);
@@ -245,6 +248,59 @@ function accountFromState() {
 
 //#endregion
 //#region src/lib/api-config.ts
+const isOpencodeOauthApp = () => {
+	return process.env.COPILOT_API_OAUTH_APP?.trim() === "opencode";
+};
+const normalizeDomain = (input) => {
+	return input.trim().replace(/^https?:\/\//u, "").replace(/\/+$/u, "");
+};
+const getEnterpriseDomain = () => {
+	const raw = (process.env.COPILOT_API_ENTERPRISE_URL ?? "").trim();
+	if (!raw) return null;
+	return normalizeDomain(raw) || null;
+};
+const getGitHubBaseUrl = () => {
+	const resolvedDomain = getEnterpriseDomain();
+	return resolvedDomain ? `https://${resolvedDomain}` : GITHUB_BASE_URL;
+};
+const getGitHubApiBaseUrl = () => {
+	const resolvedDomain = getEnterpriseDomain();
+	return resolvedDomain ? `https://${resolvedDomain}/api/v3` : GITHUB_API_BASE_URL;
+};
+const getOpencodeOauthHeaders = () => {
+	return {
+		Accept: "application/json",
+		"Content-Type": "application/json",
+		"User-Agent": "opencode/1.2.16 ai-sdk/provider-utils/3.0.21 runtime/bun/1.3.10, opencode/1.2.16"
+	};
+};
+const getOauthUrls = () => {
+	const githubBaseUrl = getGitHubBaseUrl();
+	return {
+		deviceCodeUrl: `${githubBaseUrl}/login/device/code`,
+		accessTokenUrl: `${githubBaseUrl}/login/oauth/access_token`
+	};
+};
+const getOauthAppConfig = () => {
+	if (isOpencodeOauthApp()) return {
+		clientId: OPENCODE_GITHUB_CLIENT_ID,
+		headers: getOpencodeOauthHeaders(),
+		scope: GITHUB_APP_SCOPES
+	};
+	return {
+		clientId: GITHUB_CLIENT_ID,
+		headers: standardHeaders(),
+		scope: GITHUB_APP_SCOPES
+	};
+};
+const prepareInteractionHeaders = (sessionId, isSubagent, headers) => {
+	const sendInteractionHeaders = !isOpencodeOauthApp();
+	if (isSubagent) {
+		headers["x-initiator"] = "agent";
+		if (sendInteractionHeaders) headers["x-interaction-type"] = "conversation-subagent";
+	}
+	if (sessionId && sendInteractionHeaders) headers["x-interaction-id"] = sessionId;
+};
 const standardHeaders = () => ({
 	"content-type": "application/json",
 	accept: "application/json"
@@ -253,8 +309,21 @@ const COPILOT_VERSION = "0.38.2";
 const EDITOR_PLUGIN_VERSION = `copilot-chat/${COPILOT_VERSION}`;
 const USER_AGENT = `GitHubCopilotChat/${COPILOT_VERSION}`;
 const API_VERSION = "2025-10-01";
-const copilotBaseUrl = (account) => account.accountType === "individual" ? "https://api.githubcopilot.com" : `https://api.${account.accountType}.githubcopilot.com`;
+const copilotBaseUrl = (account) => {
+	const enterpriseDomain = getEnterpriseDomain();
+	if (enterpriseDomain) return `https://copilot-api.${enterpriseDomain}`;
+	return account.accountType === "individual" ? "https://api.githubcopilot.com" : `https://api.${account.accountType}.githubcopilot.com`;
+};
 const copilotHeaders = (account, vision = false, requestId) => {
+	if (isOpencodeOauthApp()) {
+		const headers$1 = {
+			Authorization: `Bearer ${account.copilotToken ?? account.githubToken}`,
+			...getOpencodeOauthHeaders(),
+			"Openai-Intent": "conversation-edits"
+		};
+		if (vision) headers$1["Copilot-Vision-Request"] = "true";
+		return headers$1;
+	}
 	const resolvedRequestId = requestId ?? randomUUID();
 	const headers = {
 		Authorization: `Bearer ${account.copilotToken}`,
@@ -288,6 +357,7 @@ const githubHeaders = (account) => ({
 const GITHUB_BASE_URL = "https://github.com";
 const GITHUB_CLIENT_ID = "Iv1.b507a08c87ecfe98";
 const GITHUB_APP_SCOPES = ["read:user"].join(" ");
+const OPENCODE_GITHUB_CLIENT_ID = "Ov23li8tweQw6odWQebz";
 
 //#endregion
 //#region src/lib/error.ts
@@ -324,7 +394,7 @@ async function forwardError(c, error) {
 //#region src/services/github/get-copilot-usage.ts
 const getCopilotUsage = async (account) => {
 	const ctx = account ?? accountFromState();
-	const response = await fetch(`${GITHUB_API_BASE_URL}/copilot_internal/user`, { headers: githubHeaders(ctx) });
+	const response = await fetch(`${getGitHubApiBaseUrl()}/copilot_internal/user`, { headers: githubHeaders(ctx) });
 	if (!response.ok) throw new HTTPError("Failed to get Copilot usage", response);
 	return await response.json();
 };
@@ -333,7 +403,8 @@ const getCopilotUsage = async (account) => {
 //#region src/services/github/get-user.ts
 async function getGitHubUser(account) {
 	const token = account?.githubToken ?? state.githubToken;
-	const response = await fetch(`${GITHUB_API_BASE_URL}/user`, { headers: {
+	if (!token) throw new Error("GitHub token not set");
+	const response = await fetch(`${getGitHubApiBaseUrl()}/user`, { headers: {
 		authorization: `token ${token}`,
 		...standardHeaders()
 	} });
@@ -476,7 +547,7 @@ const getUUID = (content) => {
 //#region src/services/github/get-copilot-token.ts
 const getCopilotToken = async (account) => {
 	const ctx = account ?? accountFromState();
-	const response = await fetch(`${GITHUB_API_BASE_URL}/copilot_internal/v2/token`, { headers: githubHeaders(ctx) });
+	const response = await fetch(`${getGitHubApiBaseUrl()}/copilot_internal/v2/token`, { headers: githubHeaders(ctx) });
 	if (!response.ok) throw new HTTPError("Failed to get Copilot token", response);
 	return await response.json();
 };
@@ -510,6 +581,7 @@ You interact with the user through a terminal. You have 2 ways of communicating
 - Tone of your updates MUST match your personality.`;
 const defaultConfig = {
 	auth: { apiKeys: [] },
+	providers: {},
 	extraPrompts: {
 		"gpt-5-mini": gpt5ExplorationPrompt,
 		"gpt-5.3-codex": gpt5CommentaryPrompt,
@@ -520,7 +592,8 @@ const defaultConfig = {
 	responsesApiContextManagementModels: [],
 	modelReasoningEfforts: {
 		"gpt-5-mini": "low",
-		"gpt-5.3-codex": "xhigh"
+		"gpt-5.3-codex": "xhigh",
+		"gpt-5.4": "xhigh"
 	},
 	allowOriginalModelNamesForAliases: false,
 	useFunctionApplyPatch: true,
@@ -809,6 +882,34 @@ function isForceAgentEnabled() {
 function shouldCompactUseSmallModel() {
 	return getConfig().compactUseSmallModel ?? true;
 }
+function normalizeProviderBaseUrl(url) {
+	return url.trim().replace(/\/+$/u, "");
+}
+function getProviderConfig(name) {
+	const providerName = name.trim();
+	if (!providerName) return null;
+	const provider = getConfig().providers?.[providerName];
+	if (!provider) return null;
+	if (provider.enabled === false) return null;
+	const type = provider.type ?? "anthropic";
+	if (type !== "anthropic") {
+		consola.warn(`Provider ${providerName} is ignored because only anthropic type is supported`);
+		return null;
+	}
+	const baseUrl = normalizeProviderBaseUrl(provider.baseUrl ?? "");
+	const apiKey = (provider.apiKey ?? "").trim();
+	if (!baseUrl || !apiKey) {
+		consola.warn(`Provider ${providerName} is enabled but missing baseUrl or apiKey`);
+		return null;
+	}
+	return {
+		name: providerName,
+		type,
+		baseUrl,
+		apiKey,
+		models: provider.models
+	};
+}
 
 //#endregion
 //#region src/lib/accounts-manager-auth.ts
@@ -1615,5 +1716,5 @@ var AccountsManager = class {
 const accountsManager = new AccountsManager();
 
 //#endregion
-export { GITHUB_APP_SCOPES, GITHUB_BASE_URL, GITHUB_CLIENT_ID, HTTPError, PATHS, accountFromState, accountsManager, addAccountToRegistry, cacheMacMachineId, cacheVSCodeVersion, cacheVsCodeSessionId, copilotBaseUrl, copilotHeaders, ensurePaths, forwardError, generateRequestIdFromPayload, getAliasTargetSet, getConfig, getCopilotUsage, getExtraPromptForModel, getGitHubUser, getModelAliases, getModelAliasesInfo, getModelRefreshIntervalMs, getReasoningEffortForModel, getRootSessionId, getSmallModel, getUUID, isForceAgentEnabled, isFreeModelLoadBalancingEnabled, isMessageStartInputTokensFallbackEnabled, isNullish, isResponsesApiContextManagementModel, listAccountsFromRegistry, loadAccountToken, mergeConfigWithDefaults, removeAccountFromRegistry, removeAccountToken, saveAccountToken, saveRegistry, shouldCompactUseSmallModel, sleep, standardHeaders, state };
-//# sourceMappingURL=accounts-manager-eec8Wj3_.js.map
+export { HTTPError, PATHS, accountFromState, accountsManager, addAccountToRegistry, cacheMacMachineId, cacheVSCodeVersion, cacheVsCodeSessionId, copilotBaseUrl, copilotHeaders, ensurePaths, forwardError, generateRequestIdFromPayload, getAliasTargetSet, getConfig, getCopilotUsage, getExtraPromptForModel, getGitHubUser, getModelAliases, getModelAliasesInfo, getModelRefreshIntervalMs, getOauthAppConfig, getOauthUrls, getProviderConfig, getReasoningEffortForModel, getRootSessionId, getSmallModel, getUUID, isForceAgentEnabled, isFreeModelLoadBalancingEnabled, isMessageStartInputTokensFallbackEnabled, isNullish, isResponsesApiContextManagementModel, listAccountsFromRegistry, loadAccountToken, mergeConfigWithDefaults, prepareInteractionHeaders, removeAccountFromRegistry, removeAccountToken, saveAccountToken, saveRegistry, shouldCompactUseSmallModel, sleep, state };
+//# sourceMappingURL=accounts-manager-BeKvbv0T.js.map