Initial upload from Colab

.dockerignore

@@ -0,0 +1,13 @@
+node_modules
+
+.vscode/
+
+.git/
+.github/
+.gitignore
+
+dist/
+tests/
+*.md
+
+.eslintcache

.github/FUNDING.yml

@@ -0,0 +1,15 @@
+# These are supported funding model platforms
+
+github: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
+patreon: # Replace with a single Patreon username
+open_collective: # Replace with a single Open Collective username
+ko_fi: ericc_ch
+tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+lfx_crowdfunding: # Replace with a single LFX Crowdfunding project-name e.g., cloud-foundry
+polar: # Replace with a single Polar username
+buy_me_a_coffee: # Replace with a single Buy Me a Coffee username
+thanks_dev: # Replace with a single thanks.dev username
+custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']

.github/workflows/ci.yml

@@ -0,0 +1,32 @@
+name: CI
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+    types: [opened, synchronize, reopened]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: latest
+
+      - name: Install dependencies
+        run: bun install
+
+      - name: Run linter
+        run: bun run lint:all
+
+      - name: Run type check
+        run: bun run typecheck
+
+      - name: Run tests
+        run: bun test
+
+      - name: Build
+        run: bun run build

.github/workflows/deploy-pages.yml

@@ -0,0 +1,40 @@
+name: Deploy to GitHub Pages
+
+on:
+  push:
+    branches: [ "main" ]
+  workflow_dispatch:
+
+# Sets permissions of the GITHUB_TOKEN to allow deployment to GitHub Pages
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+# Allow only one concurrent deployment, skipping runs queued between the run in-progress and latest queued.
+# However, do NOT cancel in-progress runs as we want to allow these production deployments to complete.
+concurrency:
+  group: "pages"
+  cancel-in-progress: false
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        
+      - name: Setup Pages
+        uses: actions/configure-pages@v4
+        
+      - name: Upload artifact
+        uses: actions/upload-pages-artifact@v3
+        with:
+          path: ./pages
+          
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@v4

.github/workflows/release-docker.yml

@@ -0,0 +1,91 @@
+name: Docker Build and Push
+
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+
+on:
+  push:
+    # branches: [ "main" ]
+    # Publish semver tags as releases.
+    tags: [ 'v*.*.*' ]
+    paths-ignore:
+      - 'docs/**'
+
+env:
+  # Use docker.io for Docker Hub if empty
+  REGISTRY: ghcr.io
+  # github.repository as <account>/<repo>
+  #IMAGE_NAME: ${{ github.repository }}
+
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+      # This is used to complete the identity challenge
+      # with sigstore/fulcio when running outside of PRs.
+      id-token: write
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v3
+
+      - name: Set version
+        id: version
+        run: |
+          mkdir -p handlers
+          echo ${GITHUB_REF#refs/tags/v} > handlers/VERSION
+
+      # Install the cosign tool except on PR
+      # https://github.com/sigstore/cosign-installer
+      - name: Install cosign
+        if: github.event_name != 'pull_request'
+        uses: sigstore/cosign-installer@main
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v2
+        with:
+          platforms: 'arm64,amd64'
+
+      # Workaround: https://github.com/docker/build-push-action/issues/461
+      - name: Setup Docker buildx
+        uses: docker/setup-buildx-action@v2
+
+      # Login against a Docker registry except on PR
+      # https://github.com/docker/login-action
+      - name: Log into registry ${{ env.REGISTRY }}
+        if: github.event_name != 'pull_request'
+        uses: docker/login-action@v2
+        with:
+          registry: ${{ env.REGISTRY }}
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      # Extract metadata (tags, labels) for Docker
+      # https://github.com/docker/metadata-action
+      - name: Extract Docker metadata
+        id: meta
+        uses: docker/metadata-action@v4
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          images: ${{ env.REGISTRY }}/${{ github.repository }}
+          tags: |
+            type=semver,pattern=v{{version}}
+            type=semver,pattern=v{{major}}.{{minor}}
+            type=semver,pattern=v{{major}}
+
+      # Build and push Docker image with Buildx (don't push on PR)
+      # https://github.com/docker/build-push-action
+      - name: Build and push Docker image
+        id: build-and-push
+        uses: docker/build-push-action@v3
+        with:
+          context: .
+          push: ${{ github.event_name != 'pull_request' }}
+          tags: ${{ steps.meta.outputs.tags }}
+          platforms: linux/amd64,linux/arm64
+          labels: ${{ steps.meta.outputs.labels }}
+

.github/workflows/release.yml

@@ -0,0 +1,26 @@
+name: Release
+
+permissions:
+  id-token: write
+  contents: write
+
+on:
+  push:
+    tags:
+      - "v*"
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: latest
+
+      - run: bunx changelogithub
+        env:
+          GITHUB_TOKEN: ${{secrets.GITHUB_TOKEN}}

.gitignore

@@ -0,0 +1,14 @@
+# deps
+node_modules/
+
+# local env
+*.local
+
+# aider
+.aider*
+
+# eslint cache
+.eslintcache
+
+# build output
+dist/

.vscode/settings.json

@@ -0,0 +1,8 @@
+{
+  "deno.enable": false,
+  "editor.codeActionsOnSave": {
+    "source.fixAll.eslint": "explicit",
+    "source.organizeImports": "never"
+  },
+  "typescript.tsdk": "node_modules/typescript/lib"
+}

AGENTS.md

@@ -0,0 +1,47 @@
+# AGENTS.md
+
+## Build, Lint, and Test Commands
+
+- **Build:**  
+  `bun run build` (uses tsup)
+- **Dev:**  
+  `bun run dev`
+- **Lint:**  
+  `bun run lint` (uses @echristian/eslint-config)
+- **Lint & Fix staged files:**  
+  `bunx lint-staged`
+- **Test all:**  
+   `bun test`
+- **Test single file:**  
+   `bun test tests/claude-request.test.ts`
+- **Start (prod):**  
+  `bun run start`
+
+## Code Style Guidelines
+
+- **Imports:**  
+  Use ESNext syntax. Prefer absolute imports via `~/*` for `src/*` (see `tsconfig.json`).
+- **Formatting:**  
+  Follows Prettier (with `prettier-plugin-packagejson`). Run `bun run lint` to auto-fix.
+- **Types:**  
+  Strict TypeScript (`strict: true`). Avoid `any`; use explicit types and interfaces.
+- **Naming:**  
+  Use `camelCase` for variables/functions, `PascalCase` for types/classes.
+- **Error Handling:**  
+  Use explicit error classes (see `src/lib/error.ts`). Avoid silent failures.
+- **Unused:**  
+  Unused imports/variables are errors (`noUnusedLocals`, `noUnusedParameters`).
+- **Switches:**  
+  No fallthrough in switch statements.
+- **Modules:**  
+  Use ESNext modules, no CommonJS.
+- **Testing:**  
+   Use Bun's built-in test runner. Place tests in `tests/`, name as `*.test.ts`.
+- **Linting:**  
+  Uses `@echristian/eslint-config` (see npm for details). Includes stylistic, unused imports, regex, and package.json rules.
+- **Paths:**  
+  Use path aliases (`~/*`) for imports from `src/`.
+
+---
+
+This file is tailored for agentic coding agents. For more details, see the configs in `eslint.config.js` and `tsconfig.json`. No Cursor or Copilot rules detected.

Dockerfile

@@ -0,0 +1,25 @@
+FROM oven/bun:1.2.19-alpine AS builder
+WORKDIR /app
+
+COPY ./package.json ./bun.lock ./
+RUN bun install --frozen-lockfile
+
+COPY . .
+RUN bun run build
+
+FROM oven/bun:1.2.19-alpine AS runner
+WORKDIR /app
+
+COPY ./package.json ./bun.lock ./
+RUN bun install --frozen-lockfile --production --ignore-scripts --no-cache
+
+COPY --from=builder /app/dist ./dist
+
+EXPOSE 4141
+
+HEALTHCHECK --interval=30s --timeout=5s --start-period=10s --retries=3 \
+  CMD wget --spider -q http://localhost:4141/ || exit 1
+
+COPY entrypoint.sh /entrypoint.sh
+RUN chmod +x /entrypoint.sh
+ENTRYPOINT ["/entrypoint.sh"]

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Erick Christian Purwanto
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,12 +1,351 @@
+# Copilot API Proxy
+
+> [!WARNING]
+> This is a reverse-engineered proxy of GitHub Copilot API. It is not supported by GitHub, and may break unexpectedly. Use at your own risk.
+
+> [!WARNING]
+> **GitHub Security Notice:**  
+> Excessive automated or scripted use of Copilot (including rapid or bulk requests, such as via automated tools) may trigger GitHub's abuse-detection systems.  
+> You may receive a warning from GitHub Security, and further anomalous activity could result in temporary suspension of your Copilot access.
+>
+> GitHub prohibits use of their servers for excessive automated bulk activity or any activity that places undue burden on their infrastructure.
+>
+> Please review:
+>
+> - [GitHub Acceptable Use Policies](https://docs.github.com/site-policy/acceptable-use-policies/github-acceptable-use-policies#4-spam-and-inauthentic-activity-on-github)
+> - [GitHub Copilot Terms](https://docs.github.com/site-policy/github-terms/github-terms-for-additional-products-and-features#github-copilot)
+>
+> Use this proxy responsibly to avoid account restrictions.
+
+[![ko-fi](https://ko-fi.com/img/githubbutton_sm.svg)](https://ko-fi.com/E1E519XS7W)
+
 ---
-title: Copilot Api
-emoji: 🦀
-colorFrom: yellow
-colorTo: green
-sdk: docker
-pinned: false
-license: mit
-short_description: copilot-api
+
+**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.
+
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+## Project Overview
+
+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).
+
+## Features
+
+- **OpenAI & Anthropic Compatibility**: Exposes GitHub Copilot as an OpenAI-compatible (`/v1/chat/completions`, `/v1/models`, `/v1/embeddings`) and Anthropic-compatible (`/v1/messages`) API.
+- **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.
+- **Rate Limit Control**: Manage API usage with rate-limiting options (`--rate-limit`) and a waiting mechanism (`--wait`) to prevent errors from rapid requests.
+- **Manual Request Approval**: Manually approve or deny each API request for fine-grained control over usage (`--manual`).
+- **Token Visibility**: Option to display GitHub and Copilot tokens during authentication and refresh for debugging (`--show-token`).
+- **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.
+
+## Demo
+
+https://github.com/user-attachments/assets/7654b383-669d-4eb9-b23c-06d7aefee8c5
+
+## Prerequisites
+
+- Bun (>= 1.2.x)
+- GitHub account with Copilot subscription (individual, business, or enterprise)
+
+## Installation
+
+To install dependencies, run:
+
+```sh
+bun install
+```
+
+## Using with Docker
+
+Build image
+
+```sh
+docker build -t copilot-api .
+```
+
+Run the container
+
+```sh
+# Create a directory on your host to persist the GitHub token and related data
+mkdir -p ./copilot-data
+
+# Run the container with a bind mount to persist the token
+# This ensures your authentication survives container restarts
+
+docker run -p 4141:4141 -v $(pwd)/copilot-data:/root/.local/share/copilot-api copilot-api
+```
+
+> **Note:**
+> The GitHub token and related data will be stored in `copilot-data` on your host. This is mapped to `/root/.local/share/copilot-api` inside the container, ensuring persistence across restarts.
+
+### Docker with Environment Variables
+
+You can pass the GitHub token directly to the container using environment variables:
+
+```sh
+# Build with GitHub token
+docker build --build-arg GH_TOKEN=your_github_token_here -t copilot-api .
+
+# Run with GitHub token
+docker run -p 4141:4141 -e GH_TOKEN=your_github_token_here copilot-api
+
+# Run with additional options
+docker run -p 4141:4141 -e GH_TOKEN=your_token copilot-api start --verbose --port 4141
+```
+
+### Docker Compose Example
+
+```yaml
+version: "3.8"
+services:
+  copilot-api:
+    build: .
+    ports:
+      - "4141:4141"
+    environment:
+      - GH_TOKEN=your_github_token_here
+    restart: unless-stopped
+```
+
+The Docker image includes:
+
+- Multi-stage build for optimized image size
+- Non-root user for enhanced security
+- Health check for container monitoring
+- Pinned base image version for reproducible builds
+
+## Using with npx
+
+You can run the project directly using npx:
+
+```sh
+npx copilot-api@latest start
+```
+
+With options:
+
+```sh
+npx copilot-api@latest start --port 8080
+```
+
+For authentication only:
+
+```sh
+npx copilot-api@latest auth
+```
+
+## Command Structure
+
+Copilot API now uses a subcommand structure with these main commands:
+
+- `start`: Start the Copilot API server. This command will also handle authentication if needed.
+- `auth`: Run GitHub authentication flow without starting the server. This is typically used if you need to generate a token for use with the `--github-token` option, especially in non-interactive environments.
+- `check-usage`: Show your current GitHub Copilot usage and quota information directly in the terminal (no server required).
+- `debug`: Display diagnostic information including version, runtime details, file paths, and authentication status. Useful for troubleshooting and support.
+
+## Command Line Options
+
+### Start Command Options
+
+The following command line options are available for the `start` command:
+
+| Option         | Description                                                                   | Default    | Alias |
+| -------------- | ----------------------------------------------------------------------------- | ---------- | ----- |
+| --port         | Port to listen on                                                             | 4141       | -p    |
+| --verbose      | Enable verbose logging                                                        | false      | -v    |
+| --account-type | Account type to use (individual, business, enterprise)                        | individual | -a    |
+| --manual       | Enable manual request approval                                                | false      | none  |
+| --rate-limit   | Rate limit in seconds between requests                                        | none       | -r    |
+| --wait         | Wait instead of error when rate limit is hit                                  | false      | -w    |
+| --github-token | Provide GitHub token directly (must be generated using the `auth` subcommand) | none       | -g    |
+| --claude-code  | Generate a command to launch Claude Code with Copilot API config              | false      | -c    |
+| --show-token   | Show GitHub and Copilot tokens on fetch and refresh                           | false      | none  |
+| --proxy-env    | Initialize proxy from environment variables                                   | false      | none  |
+
+### Auth Command Options
+
+| Option       | Description               | Default | Alias |
+| ------------ | ------------------------- | ------- | ----- |
+| --verbose    | Enable verbose logging    | false   | -v    |
+| --show-token | Show GitHub token on auth | false   | none  |
+
+### Debug Command Options
+
+| Option | Description               | Default | Alias |
+| ------ | ------------------------- | ------- | ----- |
+| --json | Output debug info as JSON | false   | none  |
+
+## API Endpoints
+
+The server exposes several endpoints to interact with the Copilot API. It provides OpenAI-compatible endpoints and now also includes support for Anthropic-compatible endpoints, allowing for greater flexibility with different tools and services.
+
+### OpenAI Compatible Endpoints
+
+These endpoints mimic the OpenAI API structure.
+
+| Endpoint                    | Method | Description                                               |
+| --------------------------- | ------ | --------------------------------------------------------- |
+| `POST /v1/chat/completions` | `POST` | Creates a model response for the given chat conversation. |
+| `GET /v1/models`            | `GET`  | Lists the currently available models.                     |
+| `POST /v1/embeddings`       | `POST` | Creates an embedding vector representing the input text.  |
+
+### Anthropic Compatible Endpoints
+
+These endpoints are designed to be compatible with the Anthropic Messages API.
+
+| Endpoint                         | Method | Description                                                  |
+| -------------------------------- | ------ | ------------------------------------------------------------ |
+| `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. |
+
+### Usage Monitoring Endpoints
+
+New endpoints for monitoring your Copilot usage and quotas.
+
+| Endpoint     | Method | Description                                                  |
+| ------------ | ------ | ------------------------------------------------------------ |
+| `GET /usage` | `GET`  | Get detailed Copilot usage statistics and quota information. |
+| `GET /token` | `GET`  | Get the current Copilot token being used by the API.         |
+
+## Example Usage
+
+Using with npx:
+
+```sh
+# Basic usage with start command
+npx copilot-api@latest start
+
+# Run on custom port with verbose logging
+npx copilot-api@latest start --port 8080 --verbose
+
+# Use with a business plan GitHub account
+npx copilot-api@latest start --account-type business
+
+# Use with an enterprise plan GitHub account
+npx copilot-api@latest start --account-type enterprise
+
+# Enable manual approval for each request
+npx copilot-api@latest start --manual
+
+# Set rate limit to 30 seconds between requests
+npx copilot-api@latest start --rate-limit 30
+
+# Wait instead of error when rate limit is hit
+npx copilot-api@latest start --rate-limit 30 --wait
+
+# Provide GitHub token directly
+npx copilot-api@latest start --github-token ghp_YOUR_TOKEN_HERE
+
+# Run only the auth flow
+npx copilot-api@latest auth
+
+# Run auth flow with verbose logging
+npx copilot-api@latest auth --verbose
+
+# Show your Copilot usage/quota in the terminal (no server needed)
+npx copilot-api@latest check-usage
+
+# Display debug information for troubleshooting
+npx copilot-api@latest debug
+
+# Display debug information in JSON format
+npx copilot-api@latest debug --json
+
+# Initialize proxy from environment variables (HTTP_PROXY, HTTPS_PROXY, etc.)
+npx copilot-api@latest start --proxy-env
+```
+
+## Using the Usage Viewer
+
+After starting the server, a URL to the Copilot Usage Dashboard will be displayed in your console. This dashboard is a web interface for monitoring your API usage.
+
+1.  Start the server. For example, using npx:
+    ```sh
+    npx copilot-api@latest start
+    ```
+2.  The server will output a URL to the usage viewer. Copy and paste this URL into your browser. It will look something like this:
+    `https://ericc-ch.github.io/copilot-api?endpoint=http://localhost:4141/usage`
+    - If you use the `start.bat` script on Windows, this page will open automatically.
+
+The dashboard provides a user-friendly interface to view your Copilot usage data:
+
+- **API Endpoint URL**: The dashboard is pre-configured to fetch data from your local server endpoint via the URL query parameter. You can change this URL to point to any other compatible API endpoint.
+- **Fetch Data**: Click the "Fetch" button to load or refresh the usage data. The dashboard will automatically fetch data on load.
+- **Usage Quotas**: View a summary of your usage quotas for different services like Chat and Completions, displayed with progress bars for a quick overview.
+- **Detailed Information**: See the full JSON response from the API for a detailed breakdown of all available usage statistics.
+- **URL-based Configuration**: You can also specify the API endpoint directly in the URL using a query parameter. This is useful for bookmarks or sharing links. For example:
+  `https://ericc-ch.github.io/copilot-api?endpoint=http://your-api-server/usage`
+
+## Using with Claude Code
+
+This proxy can be used to power [Claude Code](https://docs.anthropic.com/en/claude-code), an experimental conversational AI assistant for developers from Anthropic.
+
+There are two ways to configure Claude Code to use this proxy:
+
+### Interactive Setup with `--claude-code` flag
+
+To get started, run the `start` command with the `--claude-code` flag:
+
+```sh
+npx copilot-api@latest start --claude-code
+```
+
+You will be prompted to select a primary model and a "small, fast" model for background tasks. After selecting the models, a command will be copied to your clipboard. This command sets the necessary environment variables for Claude Code to use the proxy.
+
+Paste and run this command in a new terminal to launch Claude Code.
+
+### Manual Configuration with `settings.json`
+
+Alternatively, you can configure Claude Code by creating a `.claude/settings.json` file in your project's root directory. This file should contain the environment variables needed by Claude Code. This way you don't need to run the interactive setup every time.
+
+Here is an example `.claude/settings.json` file:
+
+```json
+{
+  "env": {
+    "ANTHROPIC_BASE_URL": "http://localhost:4141",
+    "ANTHROPIC_AUTH_TOKEN": "dummy",
+    "ANTHROPIC_MODEL": "gpt-4.1",
+    "ANTHROPIC_DEFAULT_SONNET_MODEL": "gpt-4.1",
+    "ANTHROPIC_SMALL_FAST_MODEL": "gpt-4.1",
+    "ANTHROPIC_DEFAULT_HAIKU_MODEL": "gpt-4.1",
+    "DISABLE_NON_ESSENTIAL_MODEL_CALLS": "1",
+    "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": "1"
+  },
+  "permissions": {
+    "deny": [
+      "WebSearch"
+    ]
+  }
+}
+```
+
+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)
+
+## Running from Source
+
+The project can be run from source in several ways:
+
+### Development Mode
+
+```sh
+bun run dev
+```
+
+### Production Mode
+
+```sh
+bun run start
+```
+
+## Usage Tips
+
+- To avoid hitting GitHub Copilot's rate limits, you can use the following flags:
+  - `--manual`: Enables manual approval for each request, giving you full control over when requests are sent.
+  - `--rate-limit <seconds>`: Enforces a minimum time interval between requests. For example, `copilot-api start --rate-limit 30` will ensure there's at least a 30-second gap between requests.
+  - `--wait`: Use this with `--rate-limit`. It makes the server wait for the cooldown period to end instead of rejecting the request with an error. This is useful for clients that don't automatically retry on rate limit errors.
+- If you have a GitHub business or enterprise plan account with Copilot, use the `--account-type` flag (e.g., `--account-type business`). See the [official documentation](https://docs.github.com/en/enterprise-cloud@latest/copilot/managing-copilot/managing-github-copilot-in-your-organization/managing-access-to-github-copilot-in-your-organization/managing-github-copilot-access-to-your-organizations-network#configuring-copilot-subscription-based-network-routing-for-your-enterprise-or-organization) for more details.

entrypoint.sh

@@ -0,0 +1,9 @@
+#!/bin/sh
+if [ "$1" = "--auth" ]; then
+  # Run auth command
+  exec bun run dist/main.js auth
+else
+  # Default command
+  exec bun run dist/main.js start -g "$GH_TOKEN" "$@"
+fi
+

eslint.config.js

@@ -0,0 +1,7 @@
+import config from "@echristian/eslint-config"
+
+export default config({
+  prettier: {
+    plugins: ["prettier-plugin-packagejson"],
+  },
+})

opencode.json

@@ -0,0 +1,20 @@
+{
+  "mcp": {
+    "playwright": {
+      "type": "local",
+      "command": [
+        "docker",
+        "container",
+        "run",
+        "-i",
+        "--rm",
+        "--init",
+        "--network",
+        "host",
+        "mcr.microsoft.com/playwright/mcp"
+      ],
+      "enabled": true
+    }
+  },
+  "$schema": "https://opencode.ai/config.json"
+}

package.json

@@ -0,0 +1,68 @@
+{
+  "name": "copilot-api",
+  "version": "0.7.0",
+  "description": "Turn GitHub Copilot into OpenAI/Anthropic API compatible server. Usable with Claude Code!",
+  "keywords": [
+    "proxy",
+    "github-copilot",
+    "openai-compatible"
+  ],
+  "homepage": "https://github.com/ericc-ch/copilot-api",
+  "bugs": "https://github.com/ericc-ch/copilot-api/issues",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ericc-ch/copilot-api.git"
+  },
+  "author": "Erick Christian <[email protected]>",
+  "type": "module",
+  "bin": {
+    "copilot-api": "./dist/main.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsdown",
+    "dev": "bun run --watch ./src/main.ts",
+    "knip": "knip-bun",
+    "lint": "eslint --cache",
+    "lint:all": "eslint --cache .",
+    "prepack": "bun run build",
+    "prepare": "simple-git-hooks",
+    "release": "bumpp && bun publish --access public",
+    "start": "NODE_ENV=production bun run ./src/main.ts",
+    "typecheck": "tsc"
+  },
+  "simple-git-hooks": {
+    "pre-commit": "bunx lint-staged"
+  },
+  "lint-staged": {
+    "*": "bun run lint --fix"
+  },
+  "dependencies": {
+    "citty": "^0.1.6",
+    "clipboardy": "^5.0.0",
+    "consola": "^3.4.2",
+    "fetch-event-stream": "^0.1.5",
+    "gpt-tokenizer": "^3.0.1",
+    "hono": "^4.9.9",
+    "proxy-from-env": "^1.1.0",
+    "srvx": "^0.8.9",
+    "tiny-invariant": "^1.3.3",
+    "undici": "^7.16.0",
+    "zod": "^4.1.11"
+  },
+  "devDependencies": {
+    "@echristian/eslint-config": "^0.0.54",
+    "@types/bun": "^1.2.23",
+    "@types/proxy-from-env": "^1.0.4",
+    "bumpp": "^10.2.3",
+    "eslint": "^9.37.0",
+    "knip": "^5.64.1",
+    "lint-staged": "^16.2.3",
+    "prettier-plugin-packagejson": "^2.5.19",
+    "simple-git-hooks": "^2.13.1",
+    "tsdown": "^0.15.6",
+    "typescript": "^5.9.3"
+  }
+}

pages/index.html

@@ -0,0 +1,556 @@
+<!doctype html>
+<html lang="en" class="dark">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Copilot API Usage Dashboard</title>
+
+    <script src="https://cdn.tailwindcss.com"></script>
+
+    <link rel="preconnect" href="https://fonts.googleapis.com" />
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+    <link
+      href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap"
+      rel="stylesheet"
+    />
+
+    <script src="https://unpkg.com/[email protected]/dist/umd/lucide.min.js"></script>
+
+    <style>
+      /* Gruvbox-themed color palette */
+      :root {
+        /* Main Color Palette */
+        --color-red: #cc241d;
+        --color-green: #98971a;
+        --color-yellow: #d79921;
+        --color-blue: #458588;
+        --color-purple: #b16286;
+        --color-aqua: #689d6a;
+        --color-orange: #d65d0e;
+        --color-gray: #a89984;
+
+        /* Accent/Lighter/Darker Shades of Main Colors */
+        --color-red-accent: #fb4934;
+        --color-green-accent: #b8bb26;
+        --color-yellow-accent: #fabd2f;
+        --color-blue-accent: #83a598;
+        --color-purple-accent: #d3869b;
+        --color-aqua-accent: #8ec07c;
+        --color-orange-accent: #fe8019;
+        --color-gray-accent: #928374;
+
+        /* Background Colors */
+        --color-bg-darkest: #1d2021; /* bg0_h */
+        --color-bg: #282828; /* bg and bg0 */
+        --color-bg-light-1: #3c3836; /* bg1 */
+        --color-bg-light-2: #504945; /* bg2 */
+        --color-bg-light-3: #665c54; /* bg3 */
+        --color-bg-light-4: #7c6f64; /* bg4 */
+        --color-bg-soft: #32302f; /* bg0_s */
+
+        /* Foreground Colors */
+        --color-fg-darker: #a89984; /* fg4 - duplicate of gray */
+        --color-fg-dark: #bdae93; /* fg3 */
+        --color-fg-medium: #d5c4a1; /* fg2 */
+        --color-fg-light: #ebdbb2; /* fg and fg1 */
+        --color-fg-lightest: #fbf1c7; /* fg0 */
+      }
+
+      /* Custom styles using the new palette */
+      body {
+        font-family: "Inter", sans-serif;
+        background-color: var(--color-bg-darkest);
+        color: var(--color-fg-light);
+      }
+
+      /* Custom progress bar styles */
+      .progress-bar-bg {
+        background-color: var(--color-bg-light-1);
+      }
+      .progress-bar-fg {
+        transition: width 0.5s ease-in-out;
+      }
+
+      /* Custom scrollbar for the raw data view */
+      .code-block::-webkit-scrollbar {
+        width: 8px;
+        height: 8px;
+      }
+      .code-block::-webkit-scrollbar-track {
+        background: var(--color-bg);
+      }
+      .code-block::-webkit-scrollbar-thumb {
+        background: var(--color-bg-light-3);
+      }
+      .code-block::-webkit-scrollbar-thumb:hover {
+        background: var(--color-bg-light-4);
+      }
+
+      /* Style for focus rings to use variables */
+      .input-focus:focus {
+        --tw-ring-color: var(--color-blue);
+        border-color: var(--color-blue);
+      }
+
+
+    </style>
+  </head>
+  <body class="antialiased">
+    <div id="app" class="min-h-screen p-4 sm:p-6">
+      <div class="max-w-7xl mx-auto">
+        <!-- Header Section -->
+        <header class="mb-6">
+          <h1
+            class="text-2xl font-bold flex items-center gap-2"
+            style="color: var(--color-fg-lightest)"
+          >
+            <svg
+              xmlns="http://www.w3.org/2000/svg"
+              width="24"
+              height="24"
+              viewBox="0 0 24 24"
+              fill="none"
+              stroke="currentColor"
+              stroke-width="2"
+              stroke-linecap="round"
+              stroke-linejoin="round"
+              class="lucide lucide-gauge-circle h-7 w-7"
+              style="color: var(--color-aqua-accent)"
+            >
+              <path d="M15.6 3.3a10 10 0 1 0 5.1 5.1" />
+              <path
+                d="M12 12a1 1 0 0 0-1-1v4a1 1 0 0 0 1 1h4a1 1 0 0 0 1-1v-2a1 1 0 0 0-1-1h-3z"
+              />
+              <path d="M12 6.8a10 10 0 0 0 -3.2 7.2" />
+            </svg>
+            <span>Copilot API Usage Dashboard</span>
+          </h1>
+          <p class="mt-1 text-sm" style="color: var(--color-gray)">
+            Should be the same as the one in VSCode
+          </p>
+        </header>
+
+        <!-- Form Section -->
+        <div
+          class="mb-6 p-4 border"
+          style="
+            background-color: var(--color-bg-soft);
+            border-color: var(--color-bg-light-2);
+          "
+        >
+          <form
+            id="endpoint-form"
+            class="flex flex-col sm:flex-row items-center gap-3"
+          >
+            <label
+              for="endpoint-url"
+              class="font-semibold whitespace-nowrap text-sm"
+              style="color: var(--color-fg-lightest)"
+              >API Endpoint URL</label
+            >
+            <input
+              type="text"
+              id="endpoint-url"
+              class="w-full px-3 py-1.5 border focus:ring-1 transition input-focus text-sm"
+              style="
+                background-color: var(--color-bg-darkest);
+                border-color: var(--color-bg-light-3);
+                color: var(--color-fg-medium);
+              "
+              placeholder="http://localhost:4141/usage"
+            />
+            <button
+              id="fetch-button"
+              type="submit"
+              class="w-full sm:w-auto font-bold py-1.5 px-5 transition-colors flex items-center justify-center gap-2 text-sm"
+              style="
+                background-color: var(--color-blue);
+                color: var(--color-bg-darkest);
+              "
+            >
+              <svg
+                xmlns="http://www.w3.org/2000/svg"
+                width="24"
+                height="24"
+                viewBox="0 0 24 24"
+                fill="none"
+                stroke="currentColor"
+                stroke-width="2"
+                stroke-linecap="round"
+                stroke-linejoin="round"
+                class="lucide lucide-refresh-cw h-4 w-4"
+              >
+                <path d="M3 12a9 9 0 0 1 9-9 9.75 9.75 0 0 1 6.74 2.74L21 8" />
+                <path d="M21 3v5h-5" />
+                <path d="M21 12a9 9 0 0 1-9 9 9.75 9.75 0 0 1-6.74-2.74L3 16" />
+                <path d="M3 21v-5h5" />
+              </svg>
+              <span>Fetch</span>
+            </button>
+          </form>
+        </div>
+
+        <!-- Content Area for dynamic data -->
+        <main id="content-area"></main>
+      </div>
+    </div>
+
+    <script>
+      document.addEventListener("DOMContentLoaded", () => {
+        const endpointForm = document.getElementById("endpoint-form");
+        const endpointUrlInput = document.getElementById("endpoint-url");
+        const contentArea = document.getElementById("content-area");
+        const fetchButton = document.getElementById("fetch-button");
+
+        // Apply hover effect for fetch button via JS
+        fetchButton.addEventListener("mouseenter", () => {
+          fetchButton.style.backgroundColor = "var(--color-blue-accent)";
+        });
+        fetchButton.addEventListener("mouseleave", () => {
+          fetchButton.style.backgroundColor = "var(--color-blue)";
+        });
+
+        const DEFAULT_ENDPOINT = "http://localhost:4141/usage";
+
+        // --- State Management ---
+        const state = {
+          isLoading: false,
+          error: null,
+          data: null,
+        };
+
+        // --- Rendering Logic ---
+
+        /**
+         * Safely calls lucide.createIcons() if the library is available.
+         */
+        function createIcons() {
+          if (typeof lucide !== "undefined") {
+            lucide.createIcons();
+          }
+        }
+
+        /**
+         * Renders the entire UI based on the current state.
+         */
+        function render() {
+          if (state.isLoading) {
+            contentArea.innerHTML = renderSpinner();
+            return;
+          }
+          if (state.error) {
+            contentArea.innerHTML = renderError(state.error);
+          } else if (state.data) {
+            contentArea.innerHTML = `
+                        ${renderUsageQuotas(state.data.quota_snapshots)}
+                        ${renderDetailedData(state.data)}
+                    `;
+          } else {
+            contentArea.innerHTML = renderWelcomeMessage();
+          }
+          // Replace placeholder icons with actual Lucide icons
+          createIcons();
+        }
+
+        /**
+         * Renders the "Usage Quotas" section with progress bars.
+         * @param {object} snapshots - The quota_snapshots object from the API response.
+         * @returns {string} HTML string for the usage quotas section.
+         */
+        function renderUsageQuotas(snapshots) {
+          if (!snapshots) return "";
+
+          const quotaCards = Object.entries(snapshots)
+            .map(([key, value]) => {
+              return renderQuotaCard(key, value);
+            })
+            .join("");
+
+          return `
+                    <section id="usage-quotas" class="mb-6">
+                        <h2 class="text-xl font-bold mb-3 flex items-center gap-2" style="color: var(--color-fg-lightest);">
+                            <i data-lucide="bar-chart-big"></i> Usage Quotas
+                        </h2>
+                        <div class="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-4">
+                            ${quotaCards}
+                        </div>
+                    </section>
+                `;
+        }
+
+        /**
+         * Renders a single quota card.
+         * @param {string} title - The name of the quota (e.g., 'chat').
+         * @param {object} details - The details object for the quota.
+         * @returns {string} HTML string for a single card.
+         */
+        function renderQuotaCard(title, details) {
+          const { entitlement, remaining, percent_remaining, unlimited } =
+            details;
+
+          const percentUsed = unlimited ? 0 : 100 - percent_remaining;
+          const used = unlimited
+            ? "N/A"
+            : (entitlement - remaining).toLocaleString();
+
+          let progressBarColor = "var(--color-green)";
+          if (percentUsed > 75) progressBarColor = "var(--color-yellow)";
+          if (percentUsed > 90) progressBarColor = "var(--color-red)";
+          if (unlimited) progressBarColor = "var(--color-blue)";
+
+          return `
+                    <div class="p-4 border" style="background-color: var(--color-bg); border-color: var(--color-bg-light-2);">
+                        <div class="flex justify-between items-center mb-2">
+                            <h3 class="text-md font-semibold capitalize" style="color: var(--color-fg-lightest);">${title.replace(/_/g, " ")}</h3>
+                            ${
+                              unlimited
+                                ? `<span class="px-2 py-0.5 text-xs font-medium" style="color: var(--color-blue-accent); background-color: var(--color-bg-light-1);">Unlimited</span>`
+                                : `<span class="text-sm font-mono" style="color: var(--color-fg-medium);">${percentUsed.toFixed(1)}% Used</span>`
+                            }
+                        </div>
+                        <div class="mb-3">
+                             <div class="w-full progress-bar-bg h-2">
+                                 <div class="progress-bar-fg h-2" style="width: ${unlimited ? 100 : percentUsed}%; background-color: ${progressBarColor};"></div>
+                             </div>
+                        </div>
+                        <div class="flex justify-between text-xs font-mono" style="color: var(--color-fg-dark);">
+                            <span>${used} / ${unlimited ? "∞" : entitlement.toLocaleString()}</span>
+                            <span>${unlimited ? "∞" : remaining.toLocaleString()} remaining</span>
+                        </div>
+                    </div>
+                `;
+        }
+
+        /**
+         * Recursively builds a formatted HTML list from a JSON object.
+         * @param {object} obj - The object to format.
+         * @returns {string} HTML string for the formatted list.
+         */
+        function formatObject(obj) {
+          if (obj === null || typeof obj !== "object") {
+            return `<span style="color: var(--color-green-accent);">${JSON.stringify(obj)}</span>`;
+          }
+
+          return (
+            '<div class="pl-4">' +
+            Object.entries(obj)
+              .map(([key, value]) => {
+                const formattedKey = key.replace(/_/g, " ");
+                let displayValue;
+
+                if (Array.isArray(value)) {
+                  displayValue =
+                    value.length > 0
+                      ? `<span style='color: var(--color-gray-accent)'>[...${value.length} items]</span>`
+                      : `<span style='color: var(--color-gray-accent)'>[]</span>`;
+                } else if (typeof value === "object" && value !== null) {
+                  displayValue = formatObject(value);
+                } else if (typeof value === "boolean") {
+                  displayValue = `<span class="font-semibold" style="color: ${value ? "var(--color-green-accent)" : "var(--color-red-accent)"}">${value}</span>`;
+                } else {
+                  displayValue = `<span style="color: var(--color-blue-accent);">${JSON.stringify(value)}</span>`;
+                }
+
+                return `<div class="mt-1">
+                                <span class="capitalize font-semibold" style="color: var(--color-fg-medium);">${formattedKey}:</span>
+                                ${typeof value === "object" && value !== null && !Array.isArray(value) ? displayValue : ` ${displayValue}`}
+                           </div>`;
+              })
+              .join("") +
+            "</div>"
+          );
+        }
+
+        /**
+         * Renders the section with the full, formatted API response.
+         * @param {object} data - The full API response data.
+         * @returns {string} HTML string for the full data section.
+         */
+        function renderDetailedData(data) {
+          const formattedDetails = formatObject(data);
+          return `
+                    <section id="detailed-data">
+                        <h2 class="text-xl font-bold mb-3 flex items-center gap-2" style="color: var(--color-fg-lightest);">
+                           <i data-lucide="file-text"></i> Detailed Information
+                        </h2>
+                        <div class="border p-4 relative font-mono text-xs" style="background-color: var(--color-bg-darkest); border-color: var(--color-bg-light-2);">
+                            ${formattedDetails}
+                        </div>
+                    </section>
+                `;
+        }
+
+        /**
+         * Renders a loading spinner.
+         * @returns {string} HTML string for the spinner.
+         */
+        function renderSpinner() {
+          return `
+            <div class="flex justify-center items-center py-20">
+                <div class="animate-spin h-12 w-12 rounded-full border-4 border-transparent border-t-4" style="border-top-color: var(--color-blue);"></div>
+            </div>`;
+        }
+
+        /**
+         * Renders an error message box.
+         * @param {string} message - The error message to display.
+         * @returns {string} HTML string for the error message.
+         */
+        function renderError(message) {
+          const container = document.createElement("div");
+          container.className = "p-3 border";
+          container.style.backgroundColor = "rgba(204, 36, 29, 0.2)";
+          container.style.borderColor = "var(--color-red)";
+          container.style.color = "var(--color-red-accent)";
+          container.setAttribute("role", "alert");
+
+          container.innerHTML = `
+                <div class="flex items-center">
+                    <i data-lucide="alert-triangle" class="h-5 w-5 mr-3"></i>
+                    <div>
+                        <p class="font-bold text-sm">An Error Occurred</p>
+                        <p class="text-xs">${message}</p>
+                    </div>
+                </div>
+            `;
+          // Must create icons *after* innerHTML is set
+          setTimeout(
+            () =>
+              lucide.createIcons({
+                nodes: [container.querySelector("[data-lucide]")],
+              }),
+            0
+          );
+          return container.outerHTML;
+        }
+
+        /**
+         * Renders a welcome message when the page first loads.
+         * @returns {string} HTML string for the welcome message.
+         */
+        function renderWelcomeMessage() {
+          return `
+            <div class="text-center py-16 px-4 border" style="background-color: var(--color-bg-soft); border-color: var(--color-bg-light-2);">
+                <i data-lucide="info" class="mx-auto h-10 w-10" style="color: var(--color-gray-accent);"></i>
+                <h3 class="mt-2 text-lg font-semibold" style="color: var(--color-fg-lightest);">Welcome!</h3>
+                <p class="mt-1 text-sm" style="color: var(--color-gray);">Enter an API endpoint URL and click "Fetch" to see usage data.</p>
+            </div>
+          `;
+        }
+
+        // --- Data Fetching ---
+
+        /**
+         * Fetches data from the specified API endpoint.
+         */
+        async function fetchData() {
+          const url = endpointUrlInput.value.trim();
+          if (!url) {
+            state.error = "Endpoint URL cannot be empty.";
+            state.isLoading = false;
+            render();
+            return;
+          }
+
+          state.isLoading = true;
+          state.error = null;
+          render();
+
+          try {
+            const response = await fetch(url);
+            if (!response.ok) {
+              throw new Error(
+                `Request failed with status ${response.status}: ${response.statusText}`
+              );
+            }
+            const jsonData = await response.json();
+            state.data = jsonData;
+          } catch (error) {
+            console.error("Fetch error:", error);
+            state.data = null;
+            state.error = error.message;
+          } finally {
+            state.isLoading = false;
+            render();
+          }
+        }
+
+        // --- Event Handlers & Initialization ---
+
+        /**
+         * Handles the form submission to trigger a data fetch.
+         * @param {Event} event - The form submission event.
+         */
+        function handleFormSubmit(event) {
+          event.preventDefault();
+          const url = endpointUrlInput.value.trim();
+
+          // Update URL query parameter, catching potential security errors in sandboxed environments
+          try {
+            const currentUrl = new URL(window.location);
+            currentUrl.searchParams.set("endpoint", url);
+            window.history.pushState({}, "", currentUrl);
+          } catch (e) {
+            console.warn("Could not update URL: ", e.message);
+          }
+
+          fetchData();
+        }
+
+        /**
+         * Initializes the application.
+         */
+        function init() {
+          endpointForm.addEventListener("submit", handleFormSubmit);
+
+          // Get endpoint from URL param on load
+          const urlParams = new URLSearchParams(window.location.search);
+          const endpointFromUrl = urlParams.get("endpoint");
+
+          if (endpointFromUrl) {
+            endpointUrlInput.value = endpointFromUrl;
+            fetchData();
+          } else {
+            endpointUrlInput.value = DEFAULT_ENDPOINT;
+            render(); // Render initial welcome message
+          }
+        }
+
+        // Start the app
+        init();
+      });
+    </script>
+
+    <footer
+      class="text-center py-4 text-xs"
+      style="color: var(--color-gray-accent)"
+    >
+      <p>
+        Vibe coded by
+        <a
+          href="https://gemini.google.com"
+          target="_blank"
+          rel="noopener noreferrer"
+          class="underline transition-colors"
+          style="color: var(--color-fg-dark)"
+          onmouseover="this.style.color='var(--color-fg-light)'"
+          onmouseout="this.style.color='var(--color-fg-dark)'"
+        >
+          Gemini
+        </a>
+        - Based on
+        <a
+          href="https://github.com/uheej0625/copilot-usage-viewer"
+          target="_blank"
+          rel="noopener noreferrer"
+          class="underline transition-colors"
+          style="color: var(--color-fg-dark)"
+          onmouseover="this.style.color='var(--color-fg-light)'"
+          onmouseout="this.style.color='var(--color-fg-dark)'"
+        >
+          copilot-usage-viewer</a
+        >
+      </p>
+    </footer>
+  </body>
+</html>

src/auth.ts

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+
+import { defineCommand } from "citty"
+import consola from "consola"
+
+import { PATHS, ensurePaths } from "./lib/paths"
+import { state } from "./lib/state"
+import { setupGitHubToken } from "./lib/token"
+
+interface RunAuthOptions {
+  verbose: boolean
+  showToken: boolean
+}
+
+export async function runAuth(options: RunAuthOptions): Promise<void> {
+  if (options.verbose) {
+    consola.level = 5
+    consola.info("Verbose logging enabled")
+  }
+
+  state.showToken = options.showToken
+
+  await ensurePaths()
+  await setupGitHubToken({ force: true })
+  consola.success("GitHub token written to", PATHS.GITHUB_TOKEN_PATH)
+}
+
+export const auth = defineCommand({
+  meta: {
+    name: "auth",
+    description: "Run GitHub auth flow without running the server",
+  },
+  args: {
+    verbose: {
+      alias: "v",
+      type: "boolean",
+      default: false,
+      description: "Enable verbose logging",
+    },
+    "show-token": {
+      type: "boolean",
+      default: false,
+      description: "Show GitHub token on auth",
+    },
+  },
+  run({ args }) {
+    return runAuth({
+      verbose: args.verbose,
+      showToken: args["show-token"],
+    })
+  },
+})

src/check-usage.ts

@@ -0,0 +1,58 @@
+import { defineCommand } from "citty"
+import consola from "consola"
+
+import { ensurePaths } from "./lib/paths"
+import { setupGitHubToken } from "./lib/token"
+import {
+  getCopilotUsage,
+  type QuotaDetail,
+} from "./services/github/get-copilot-usage"
+
+export const checkUsage = defineCommand({
+  meta: {
+    name: "check-usage",
+    description: "Show current GitHub Copilot usage/quota information",
+  },
+  async run() {
+    await ensurePaths()
+    await setupGitHubToken()
+    try {
+      const usage = await getCopilotUsage()
+      const premium = usage.quota_snapshots.premium_interactions
+      const premiumTotal = premium.entitlement
+      const premiumUsed = premiumTotal - premium.remaining
+      const premiumPercentUsed =
+        premiumTotal > 0 ? (premiumUsed / premiumTotal) * 100 : 0
+      const premiumPercentRemaining = premium.percent_remaining
+
+      // Helper to summarize a quota snapshot
+      function summarizeQuota(name: string, snap: QuotaDetail | undefined) {
+        if (!snap) return `${name}: N/A`
+        const total = snap.entitlement
+        const used = total - snap.remaining
+        const percentUsed = total > 0 ? (used / total) * 100 : 0
+        const percentRemaining = snap.percent_remaining
+        return `${name}: ${used}/${total} used (${percentUsed.toFixed(1)}% used, ${percentRemaining.toFixed(1)}% remaining)`
+      }
+
+      const premiumLine = `Premium: ${premiumUsed}/${premiumTotal} used (${premiumPercentUsed.toFixed(1)}% used, ${premiumPercentRemaining.toFixed(1)}% remaining)`
+      const chatLine = summarizeQuota("Chat", usage.quota_snapshots.chat)
+      const completionsLine = summarizeQuota(
+        "Completions",
+        usage.quota_snapshots.completions,
+      )
+
+      consola.box(
+        `Copilot Usage (plan: ${usage.copilot_plan})\n`
+          + `Quota resets: ${usage.quota_reset_date}\n`
+          + `\nQuotas:\n`
+          + `  ${premiumLine}\n`
+          + `  ${chatLine}\n`
+          + `  ${completionsLine}`,
+      )
+    } catch (err) {
+      consola.error("Failed to fetch Copilot usage:", err)
+      process.exit(1)
+    }
+  },
+})

src/debug.ts

@@ -0,0 +1,127 @@
+#!/usr/bin/env node
+
+import { defineCommand } from "citty"
+import consola from "consola"
+import fs from "node:fs/promises"
+import os from "node:os"
+
+import { PATHS } from "./lib/paths"
+
+interface DebugInfo {
+  version: string
+  runtime: {
+    name: string
+    version: string
+    platform: string
+    arch: string
+  }
+  paths: {
+    APP_DIR: string
+    GITHUB_TOKEN_PATH: string
+  }
+  tokenExists: boolean
+}
+
+interface RunDebugOptions {
+  json: boolean
+}
+
+async function getPackageVersion(): Promise<string> {
+  try {
+    const packageJsonPath = new URL("../package.json", import.meta.url).pathname
+    // @ts-expect-error https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v59.0.1/docs/rules/prefer-json-parse-buffer.md
+    // JSON.parse() can actually parse buffers
+    const packageJson = JSON.parse(await fs.readFile(packageJsonPath)) as {
+      version: string
+    }
+    return packageJson.version
+  } catch {
+    return "unknown"
+  }
+}
+
+function getRuntimeInfo() {
+  const isBun = typeof Bun !== "undefined"
+
+  return {
+    name: isBun ? "bun" : "node",
+    version: isBun ? Bun.version : process.version.slice(1),
+    platform: os.platform(),
+    arch: os.arch(),
+  }
+}
+
+async function checkTokenExists(): Promise<boolean> {
+  try {
+    const stats = await fs.stat(PATHS.GITHUB_TOKEN_PATH)
+    if (!stats.isFile()) return false
+
+    const content = await fs.readFile(PATHS.GITHUB_TOKEN_PATH, "utf8")
+    return content.trim().length > 0
+  } catch {
+    return false
+  }
+}
+
+async function getDebugInfo(): Promise<DebugInfo> {
+  const [version, tokenExists] = await Promise.all([
+    getPackageVersion(),
+    checkTokenExists(),
+  ])
+
+  return {
+    version,
+    runtime: getRuntimeInfo(),
+    paths: {
+      APP_DIR: PATHS.APP_DIR,
+      GITHUB_TOKEN_PATH: PATHS.GITHUB_TOKEN_PATH,
+    },
+    tokenExists,
+  }
+}
+
+function printDebugInfoPlain(info: DebugInfo): void {
+  consola.info(`copilot-api debug
+
+Version: ${info.version}
+Runtime: ${info.runtime.name} ${info.runtime.version} (${info.runtime.platform} ${info.runtime.arch})
+
+Paths:
+- APP_DIR: ${info.paths.APP_DIR}
+- GITHUB_TOKEN_PATH: ${info.paths.GITHUB_TOKEN_PATH}
+
+Token exists: ${info.tokenExists ? "Yes" : "No"}`)
+}
+
+function printDebugInfoJson(info: DebugInfo): void {
+  console.log(JSON.stringify(info, null, 2))
+}
+
+export async function runDebug(options: RunDebugOptions): Promise<void> {
+  const debugInfo = await getDebugInfo()
+
+  if (options.json) {
+    printDebugInfoJson(debugInfo)
+  } else {
+    printDebugInfoPlain(debugInfo)
+  }
+}
+
+export const debug = defineCommand({
+  meta: {
+    name: "debug",
+    description: "Print debug information about the application",
+  },
+  args: {
+    json: {
+      type: "boolean",
+      default: false,
+      description: "Output debug information as JSON",
+    },
+  },
+  run({ args }) {
+    return runDebug({
+      json: args.json,
+    })
+  },
+})

src/lib/api-config.ts

@@ -0,0 +1,52 @@
+import { randomUUID } from "node:crypto"
+
+import type { State } from "./state"
+
+export const standardHeaders = () => ({
+  "content-type": "application/json",
+  accept: "application/json",
+})
+
+const COPILOT_VERSION = "0.26.7"
+const EDITOR_PLUGIN_VERSION = `copilot-chat/${COPILOT_VERSION}`
+const USER_AGENT = `GitHubCopilotChat/${COPILOT_VERSION}`
+
+const API_VERSION = "2025-04-01"
+
+export const copilotBaseUrl = (state: State) =>
+  state.accountType === "individual" ?
+    "https://api.githubcopilot.com"
+  : `https://api.${state.accountType}.githubcopilot.com`
+export const copilotHeaders = (state: State, vision: boolean = false) => {
+  const headers: Record<string, string> = {
+    Authorization: `Bearer ${state.copilotToken}`,
+    "content-type": standardHeaders()["content-type"],
+    "copilot-integration-id": "vscode-chat",
+    "editor-version": `vscode/${state.vsCodeVersion}`,
+    "editor-plugin-version": EDITOR_PLUGIN_VERSION,
+    "user-agent": USER_AGENT,
+    "openai-intent": "conversation-panel",
+    "x-github-api-version": API_VERSION,
+    "x-request-id": randomUUID(),
+    "x-vscode-user-agent-library-version": "electron-fetch",
+  }
+
+  if (vision) headers["copilot-vision-request"] = "true"
+
+  return headers
+}
+
+export const GITHUB_API_BASE_URL = "https://api.github.com"
+export const githubHeaders = (state: State) => ({
+  ...standardHeaders(),
+  authorization: `token ${state.githubToken}`,
+  "editor-version": `vscode/${state.vsCodeVersion}`,
+  "editor-plugin-version": EDITOR_PLUGIN_VERSION,
+  "user-agent": USER_AGENT,
+  "x-github-api-version": API_VERSION,
+  "x-vscode-user-agent-library-version": "electron-fetch",
+})
+
+export const GITHUB_BASE_URL = "https://github.com"
+export const GITHUB_CLIENT_ID = "Iv1.b507a08c87ecfe98"
+export const GITHUB_APP_SCOPES = ["read:user"].join(" ")

src/lib/approval.ts

@@ -0,0 +1,15 @@
+import consola from "consola"
+
+import { HTTPError } from "./error"
+
+export const awaitApproval = async () => {
+  const response = await consola.prompt(`Accept incoming request?`, {
+    type: "confirm",
+  })
+
+  if (!response)
+    throw new HTTPError(
+      "Request rejected",
+      Response.json({ message: "Request rejected" }, { status: 403 }),
+    )
+}

src/lib/error.ts

@@ -0,0 +1,47 @@
+import type { Context } from "hono"
+import type { ContentfulStatusCode } from "hono/utils/http-status"
+
+import consola from "consola"
+
+export class HTTPError extends Error {
+  response: Response
+
+  constructor(message: string, response: Response) {
+    super(message)
+    this.response = response
+  }
+}
+
+export async function forwardError(c: Context, error: unknown) {
+  consola.error("Error occurred:", error)
+
+  if (error instanceof HTTPError) {
+    const errorText = await error.response.text()
+    let errorJson: unknown
+    try {
+      errorJson = JSON.parse(errorText)
+    } catch {
+      errorJson = errorText
+    }
+    consola.error("HTTP error:", errorJson)
+    return c.json(
+      {
+        error: {
+          message: errorText,
+          type: "error",
+        },
+      },
+      error.response.status as ContentfulStatusCode,
+    )
+  }
+
+  return c.json(
+    {
+      error: {
+        message: (error as Error).message,
+        type: "error",
+      },
+    },
+    500,
+  )
+}

src/lib/paths.ts

@@ -0,0 +1,26 @@
+import fs from "node:fs/promises"
+import os from "node:os"
+import path from "node:path"
+
+const APP_DIR = path.join(os.homedir(), ".local", "share", "copilot-api")
+
+const GITHUB_TOKEN_PATH = path.join(APP_DIR, "github_token")
+
+export const PATHS = {
+  APP_DIR,
+  GITHUB_TOKEN_PATH,
+}
+
+export async function ensurePaths(): Promise<void> {
+  await fs.mkdir(PATHS.APP_DIR, { recursive: true })
+  await ensureFile(PATHS.GITHUB_TOKEN_PATH)
+}
+
+async function ensureFile(filePath: string): Promise<void> {
+  try {
+    await fs.access(filePath, fs.constants.W_OK)
+  } catch {
+    await fs.writeFile(filePath, "")
+    await fs.chmod(filePath, 0o600)
+  }
+}

src/lib/proxy.ts

@@ -0,0 +1,66 @@
+import consola from "consola"
+import { getProxyForUrl } from "proxy-from-env"
+import { Agent, ProxyAgent, setGlobalDispatcher, type Dispatcher } from "undici"
+
+export function initProxyFromEnv(): void {
+  if (typeof Bun !== "undefined") return
+
+  try {
+    const direct = new Agent()
+    const proxies = new Map<string, ProxyAgent>()
+
+    // We only need a minimal dispatcher that implements `dispatch` at runtime.
+    // Typing the object as `Dispatcher` forces TypeScript to require many
+    // additional methods. Instead, keep a plain object and cast when passing
+    // to `setGlobalDispatcher`.
+    const dispatcher = {
+      dispatch(
+        options: Dispatcher.DispatchOptions,
+        handler: Dispatcher.DispatchHandler,
+      ) {
+        try {
+          const origin =
+            typeof options.origin === "string" ?
+              new URL(options.origin)
+            : (options.origin as URL)
+          const get = getProxyForUrl as unknown as (
+            u: string,
+          ) => string | undefined
+          const raw = get(origin.toString())
+          const proxyUrl = raw && raw.length > 0 ? raw : undefined
+          if (!proxyUrl) {
+            consola.debug(`HTTP proxy bypass: ${origin.hostname}`)
+            return (direct as unknown as Dispatcher).dispatch(options, handler)
+          }
+          let agent = proxies.get(proxyUrl)
+          if (!agent) {
+            agent = new ProxyAgent(proxyUrl)
+            proxies.set(proxyUrl, agent)
+          }
+          let label = proxyUrl
+          try {
+            const u = new URL(proxyUrl)
+            label = `${u.protocol}//${u.host}`
+          } catch {
+            /* noop */
+          }
+          consola.debug(`HTTP proxy route: ${origin.hostname} via ${label}`)
+          return (agent as unknown as Dispatcher).dispatch(options, handler)
+        } catch {
+          return (direct as unknown as Dispatcher).dispatch(options, handler)
+        }
+      },
+      close() {
+        return direct.close()
+      },
+      destroy() {
+        return direct.destroy()
+      },
+    }
+
+    setGlobalDispatcher(dispatcher as unknown as Dispatcher)
+    consola.debug("HTTP proxy configured from environment (per-URL)")
+  } catch (err) {
+    consola.debug("Proxy setup skipped:", err)
+  }
+}

src/lib/rate-limit.ts

@@ -0,0 +1,46 @@
+import consola from "consola"
+
+import type { State } from "./state"
+
+import { HTTPError } from "./error"
+import { sleep } from "./utils"
+
+export async function checkRateLimit(state: State) {
+  if (state.rateLimitSeconds === undefined) return
+
+  const now = Date.now()
+
+  if (!state.lastRequestTimestamp) {
+    state.lastRequestTimestamp = now
+    return
+  }
+
+  const elapsedSeconds = (now - state.lastRequestTimestamp) / 1000
+
+  if (elapsedSeconds > state.rateLimitSeconds) {
+    state.lastRequestTimestamp = now
+    return
+  }
+
+  const waitTimeSeconds = Math.ceil(state.rateLimitSeconds - elapsedSeconds)
+
+  if (!state.rateLimitWait) {
+    consola.warn(
+      `Rate limit exceeded. Need to wait ${waitTimeSeconds} more seconds.`,
+    )
+    throw new HTTPError(
+      "Rate limit exceeded",
+      Response.json({ message: "Rate limit exceeded" }, { status: 429 }),
+    )
+  }
+
+  const waitTimeMs = waitTimeSeconds * 1000
+  consola.warn(
+    `Rate limit reached. Waiting ${waitTimeSeconds} seconds before proceeding...`,
+  )
+  await sleep(waitTimeMs)
+  // eslint-disable-next-line require-atomic-updates
+  state.lastRequestTimestamp = now
+  consola.info("Rate limit wait completed, proceeding with request")
+  return
+}

src/lib/shell.ts

@@ -0,0 +1,88 @@
+import { execSync } from "node:child_process"
+import process from "node:process"
+
+type ShellName = "bash" | "zsh" | "fish" | "powershell" | "cmd" | "sh"
+type EnvVars = Record<string, string | undefined>
+
+function getShell(): ShellName {
+  const { platform, ppid, env } = process
+
+  if (platform === "win32") {
+    try {
+      const command = `wmic process get ParentProcessId,Name | findstr "${ppid}"`
+      const parentProcess = execSync(command, { stdio: "pipe" }).toString()
+
+      if (parentProcess.toLowerCase().includes("powershell.exe")) {
+        return "powershell"
+      }
+    } catch {
+      return "cmd"
+    }
+
+    return "cmd"
+  } else {
+    const shellPath = env.SHELL
+    if (shellPath) {
+      if (shellPath.endsWith("zsh")) return "zsh"
+      if (shellPath.endsWith("fish")) return "fish"
+      if (shellPath.endsWith("bash")) return "bash"
+    }
+
+    return "sh"
+  }
+}
+
+/**
+ * Generates a copy-pasteable script to set multiple environment variables
+ * and run a subsequent command.
+ * @param {EnvVars} envVars - An object of environment variables to set.
+ * @param {string} commandToRun - The command to run after setting the variables.
+ * @returns {string} The formatted script string.
+ */
+export function generateEnvScript(
+  envVars: EnvVars,
+  commandToRun: string = "",
+): string {
+  const shell = getShell()
+  const filteredEnvVars = Object.entries(envVars).filter(
+    ([, value]) => value !== undefined,
+  ) as Array<[string, string]>
+
+  let commandBlock: string
+
+  switch (shell) {
+    case "powershell": {
+      commandBlock = filteredEnvVars
+        .map(([key, value]) => `$env:${key} = ${value}`)
+        .join("; ")
+      break
+    }
+    case "cmd": {
+      commandBlock = filteredEnvVars
+        .map(([key, value]) => `set ${key}=${value}`)
+        .join(" & ")
+      break
+    }
+    case "fish": {
+      commandBlock = filteredEnvVars
+        .map(([key, value]) => `set -gx ${key} ${value}`)
+        .join("; ")
+      break
+    }
+    default: {
+      // bash, zsh, sh
+      const assignments = filteredEnvVars
+        .map(([key, value]) => `${key}=${value}`)
+        .join(" ")
+      commandBlock = filteredEnvVars.length > 0 ? `export ${assignments}` : ""
+      break
+    }
+  }
+
+  if (commandBlock && commandToRun) {
+    const separator = shell === "cmd" ? " & " : " && "
+    return `${commandBlock}${separator}${commandToRun}`
+  }
+
+  return commandBlock || commandToRun
+}

src/lib/state.ts

@@ -0,0 +1,25 @@
+import type { ModelsResponse } from "~/services/copilot/get-models"
+
+export interface State {
+  githubToken?: string
+  copilotToken?: string
+
+  accountType: string
+  models?: ModelsResponse
+  vsCodeVersion?: string
+
+  manualApprove: boolean
+  rateLimitWait: boolean
+  showToken: boolean
+
+  // Rate limiting configuration
+  rateLimitSeconds?: number
+  lastRequestTimestamp?: number
+}
+
+export const state: State = {
+  accountType: "individual",
+  manualApprove: false,
+  rateLimitWait: false,
+  showToken: false,
+}

src/lib/token.ts

@@ -0,0 +1,95 @@
+import consola from "consola"
+import fs from "node:fs/promises"
+
+import { PATHS } from "~/lib/paths"
+import { getCopilotToken } from "~/services/github/get-copilot-token"
+import { getDeviceCode } from "~/services/github/get-device-code"
+import { getGitHubUser } from "~/services/github/get-user"
+import { pollAccessToken } from "~/services/github/poll-access-token"
+
+import { HTTPError } from "./error"
+import { state } from "./state"
+
+const readGithubToken = () => fs.readFile(PATHS.GITHUB_TOKEN_PATH, "utf8")
+
+const writeGithubToken = (token: string) =>
+  fs.writeFile(PATHS.GITHUB_TOKEN_PATH, token)
+
+export const setupCopilotToken = async () => {
+  const { token, refresh_in } = await getCopilotToken()
+  state.copilotToken = token
+
+  // Display the Copilot token to the screen
+  consola.debug("GitHub Copilot Token fetched successfully!")
+  if (state.showToken) {
+    consola.info("Copilot token:", token)
+  }
+
+  const refreshInterval = (refresh_in - 60) * 1000
+  setInterval(async () => {
+    consola.debug("Refreshing Copilot token")
+    try {
+      const { token } = await getCopilotToken()
+      state.copilotToken = token
+      consola.debug("Copilot token refreshed")
+      if (state.showToken) {
+        consola.info("Refreshed Copilot token:", token)
+      }
+    } catch (error) {
+      consola.error("Failed to refresh Copilot token:", error)
+      throw error
+    }
+  }, refreshInterval)
+}
+
+interface SetupGitHubTokenOptions {
+  force?: boolean
+}
+
+export async function setupGitHubToken(
+  options?: SetupGitHubTokenOptions,
+): Promise<void> {
+  try {
+    const githubToken = await readGithubToken()
+
+    if (githubToken && !options?.force) {
+      state.githubToken = githubToken
+      if (state.showToken) {
+        consola.info("GitHub token:", githubToken)
+      }
+      await logUser()
+
+      return
+    }
+
+    consola.info("Not logged in, getting new access token")
+    const response = await getDeviceCode()
+    consola.debug("Device code response:", response)
+
+    consola.info(
+      `Please enter the code "${response.user_code}" in ${response.verification_uri}`,
+    )
+
+    const token = await pollAccessToken(response)
+    await writeGithubToken(token)
+    state.githubToken = token
+
+    if (state.showToken) {
+      consola.info("GitHub token:", token)
+    }
+    await logUser()
+  } catch (error) {
+    if (error instanceof HTTPError) {
+      consola.error("Failed to get GitHub token:", await error.response.json())
+      throw error
+    }
+
+    consola.error("Failed to get GitHub token:", error)
+    throw error
+  }
+}
+
+async function logUser() {
+  const user = await getGitHubUser()
+  consola.info(`Logged in as ${user.login}`)
+}

src/lib/tokenizer.ts

@@ -0,0 +1,348 @@
+import type {
+  ChatCompletionsPayload,
+  ContentPart,
+  Message,
+  Tool,
+  ToolCall,
+} from "~/services/copilot/create-chat-completions"
+import type { Model } from "~/services/copilot/get-models"
+
+// Encoder type mapping
+const ENCODING_MAP = {
+  o200k_base: () => import("gpt-tokenizer/encoding/o200k_base"),
+  cl100k_base: () => import("gpt-tokenizer/encoding/cl100k_base"),
+  p50k_base: () => import("gpt-tokenizer/encoding/p50k_base"),
+  p50k_edit: () => import("gpt-tokenizer/encoding/p50k_edit"),
+  r50k_base: () => import("gpt-tokenizer/encoding/r50k_base"),
+} as const
+
+type SupportedEncoding = keyof typeof ENCODING_MAP
+
+// Define encoder interface
+interface Encoder {
+  encode: (text: string) => Array<number>
+}
+
+// Cache loaded encoders to avoid repeated imports
+const encodingCache = new Map<string, Encoder>()
+
+/**
+ * Calculate tokens for tool calls
+ */
+const calculateToolCallsTokens = (
+  toolCalls: Array<ToolCall>,
+  encoder: Encoder,
+  constants: ReturnType<typeof getModelConstants>,
+): number => {
+  let tokens = 0
+  for (const toolCall of toolCalls) {
+    tokens += constants.funcInit
+    tokens += encoder.encode(JSON.stringify(toolCall)).length
+  }
+  tokens += constants.funcEnd
+  return tokens
+}
+
+/**
+ * Calculate tokens for content parts
+ */
+const calculateContentPartsTokens = (
+  contentParts: Array<ContentPart>,
+  encoder: Encoder,
+): number => {
+  let tokens = 0
+  for (const part of contentParts) {
+    if (part.type === "image_url") {
+      tokens += encoder.encode(part.image_url.url).length + 85
+    } else if (part.text) {
+      tokens += encoder.encode(part.text).length
+    }
+  }
+  return tokens
+}
+
+/**
+ * Calculate tokens for a single message
+ */
+const calculateMessageTokens = (
+  message: Message,
+  encoder: Encoder,
+  constants: ReturnType<typeof getModelConstants>,
+): number => {
+  const tokensPerMessage = 3
+  const tokensPerName = 1
+  let tokens = tokensPerMessage
+  for (const [key, value] of Object.entries(message)) {
+    if (typeof value === "string") {
+      tokens += encoder.encode(value).length
+    }
+    if (key === "name") {
+      tokens += tokensPerName
+    }
+    if (key === "tool_calls") {
+      tokens += calculateToolCallsTokens(
+        value as Array<ToolCall>,
+        encoder,
+        constants,
+      )
+    }
+    if (key === "content" && Array.isArray(value)) {
+      tokens += calculateContentPartsTokens(
+        value as Array<ContentPart>,
+        encoder,
+      )
+    }
+  }
+  return tokens
+}
+
+/**
+ * Calculate tokens using custom algorithm
+ */
+const calculateTokens = (
+  messages: Array<Message>,
+  encoder: Encoder,
+  constants: ReturnType<typeof getModelConstants>,
+): number => {
+  if (messages.length === 0) {
+    return 0
+  }
+  let numTokens = 0
+  for (const message of messages) {
+    numTokens += calculateMessageTokens(message, encoder, constants)
+  }
+  // every reply is primed with <|start|>assistant<|message|>
+  numTokens += 3
+  return numTokens
+}
+
+/**
+ * Get the corresponding encoder module based on encoding type
+ */
+const getEncodeChatFunction = async (encoding: string): Promise<Encoder> => {
+  if (encodingCache.has(encoding)) {
+    const cached = encodingCache.get(encoding)
+    if (cached) {
+      return cached
+    }
+  }
+
+  const supportedEncoding = encoding as SupportedEncoding
+  if (!(supportedEncoding in ENCODING_MAP)) {
+    const fallbackModule = (await ENCODING_MAP.o200k_base()) as Encoder
+    encodingCache.set(encoding, fallbackModule)
+    return fallbackModule
+  }
+
+  const encodingModule = (await ENCODING_MAP[supportedEncoding]()) as Encoder
+  encodingCache.set(encoding, encodingModule)
+  return encodingModule
+}
+
+/**
+ * Get tokenizer type from model information
+ */
+export const getTokenizerFromModel = (model: Model): string => {
+  return model.capabilities.tokenizer || "o200k_base"
+}
+
+/**
+ * Get model-specific constants for token calculation
+ */
+const getModelConstants = (model: Model) => {
+  return model.id === "gpt-3.5-turbo" || model.id === "gpt-4" ?
+      {
+        funcInit: 10,
+        propInit: 3,
+        propKey: 3,
+        enumInit: -3,
+        enumItem: 3,
+        funcEnd: 12,
+      }
+    : {
+        funcInit: 7,
+        propInit: 3,
+        propKey: 3,
+        enumInit: -3,
+        enumItem: 3,
+        funcEnd: 12,
+      }
+}
+
+/**
+ * Calculate tokens for a single parameter
+ */
+const calculateParameterTokens = (
+  key: string,
+  prop: unknown,
+  context: {
+    encoder: Encoder
+    constants: ReturnType<typeof getModelConstants>
+  },
+): number => {
+  const { encoder, constants } = context
+  let tokens = constants.propKey
+
+  // Early return if prop is not an object
+  if (typeof prop !== "object" || prop === null) {
+    return tokens
+  }
+
+  // Type assertion for parameter properties
+  const param = prop as {
+    type?: string
+    description?: string
+    enum?: Array<unknown>
+    [key: string]: unknown
+  }
+
+  const paramName = key
+  const paramType = param.type || "string"
+  let paramDesc = param.description || ""
+
+  // Handle enum values
+  if (param.enum && Array.isArray(param.enum)) {
+    tokens += constants.enumInit
+    for (const item of param.enum) {
+      tokens += constants.enumItem
+      tokens += encoder.encode(String(item)).length
+    }
+  }
+
+  // Clean up description
+  if (paramDesc.endsWith(".")) {
+    paramDesc = paramDesc.slice(0, -1)
+  }
+
+  // Encode the main parameter line
+  const line = `${paramName}:${paramType}:${paramDesc}`
+  tokens += encoder.encode(line).length
+
+  // Handle additional properties (excluding standard ones)
+  const excludedKeys = new Set(["type", "description", "enum"])
+  for (const propertyName of Object.keys(param)) {
+    if (!excludedKeys.has(propertyName)) {
+      const propertyValue = param[propertyName]
+      const propertyText =
+        typeof propertyValue === "string" ? propertyValue : (
+          JSON.stringify(propertyValue)
+        )
+      tokens += encoder.encode(`${propertyName}:${propertyText}`).length
+    }
+  }
+
+  return tokens
+}
+
+/**
+ * Calculate tokens for function parameters
+ */
+const calculateParametersTokens = (
+  parameters: unknown,
+  encoder: Encoder,
+  constants: ReturnType<typeof getModelConstants>,
+): number => {
+  if (!parameters || typeof parameters !== "object") {
+    return 0
+  }
+
+  const params = parameters as Record<string, unknown>
+  let tokens = 0
+
+  for (const [key, value] of Object.entries(params)) {
+    if (key === "properties") {
+      const properties = value as Record<string, unknown>
+      if (Object.keys(properties).length > 0) {
+        tokens += constants.propInit
+        for (const propKey of Object.keys(properties)) {
+          tokens += calculateParameterTokens(propKey, properties[propKey], {
+            encoder,
+            constants,
+          })
+        }
+      }
+    } else {
+      const paramText =
+        typeof value === "string" ? value : JSON.stringify(value)
+      tokens += encoder.encode(`${key}:${paramText}`).length
+    }
+  }
+
+  return tokens
+}
+
+/**
+ * Calculate tokens for a single tool
+ */
+const calculateToolTokens = (
+  tool: Tool,
+  encoder: Encoder,
+  constants: ReturnType<typeof getModelConstants>,
+): number => {
+  let tokens = constants.funcInit
+  const func = tool.function
+  const fName = func.name
+  let fDesc = func.description || ""
+  if (fDesc.endsWith(".")) {
+    fDesc = fDesc.slice(0, -1)
+  }
+  const line = fName + ":" + fDesc
+  tokens += encoder.encode(line).length
+  if (
+    typeof func.parameters === "object" // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    && func.parameters !== null
+  ) {
+    tokens += calculateParametersTokens(func.parameters, encoder, constants)
+  }
+  return tokens
+}
+
+/**
+ * Calculate token count for tools based on model
+ */
+export const numTokensForTools = (
+  tools: Array<Tool>,
+  encoder: Encoder,
+  constants: ReturnType<typeof getModelConstants>,
+): number => {
+  let funcTokenCount = 0
+  for (const tool of tools) {
+    funcTokenCount += calculateToolTokens(tool, encoder, constants)
+  }
+  funcTokenCount += constants.funcEnd
+  return funcTokenCount
+}
+
+/**
+ * Calculate the token count of messages, supporting multiple GPT encoders
+ */
+export const getTokenCount = async (
+  payload: ChatCompletionsPayload,
+  model: Model,
+): Promise<{ input: number; output: number }> => {
+  // Get tokenizer string
+  const tokenizer = getTokenizerFromModel(model)
+
+  // Get corresponding encoder module
+  const encoder = await getEncodeChatFunction(tokenizer)
+
+  const simplifiedMessages = payload.messages
+  const inputMessages = simplifiedMessages.filter(
+    (msg) => msg.role !== "assistant",
+  )
+  const outputMessages = simplifiedMessages.filter(
+    (msg) => msg.role === "assistant",
+  )
+
+  const constants = getModelConstants(model)
+  let inputTokens = calculateTokens(inputMessages, encoder, constants)
+  if (payload.tools && payload.tools.length > 0) {
+    inputTokens += numTokensForTools(payload.tools, encoder, constants)
+  }
+  const outputTokens = calculateTokens(outputMessages, encoder, constants)
+
+  return {
+    input: inputTokens,
+    output: outputTokens,
+  }
+}

src/lib/utils.ts

@@ -0,0 +1,26 @@
+import consola from "consola"
+
+import { getModels } from "~/services/copilot/get-models"
+import { getVSCodeVersion } from "~/services/get-vscode-version"
+
+import { state } from "./state"
+
+export const sleep = (ms: number) =>
+  new Promise((resolve) => {
+    setTimeout(resolve, ms)
+  })
+
+export const isNullish = (value: unknown): value is null | undefined =>
+  value === null || value === undefined
+
+export async function cacheModels(): Promise<void> {
+  const models = await getModels()
+  state.models = models
+}
+
+export const cacheVSCodeVersion = async () => {
+  const response = await getVSCodeVersion()
+  state.vsCodeVersion = response
+
+  consola.info(`Using VSCode version: ${response}`)
+}

src/main.ts

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+
+import { defineCommand, runMain } from "citty"
+
+import { auth } from "./auth"
+import { checkUsage } from "./check-usage"
+import { debug } from "./debug"
+import { start } from "./start"
+
+const main = defineCommand({
+  meta: {
+    name: "copilot-api",
+    description:
+      "A wrapper around GitHub Copilot API to make it OpenAI compatible, making it usable for other tools.",
+  },
+  subCommands: { auth, start, "check-usage": checkUsage, debug },
+})
+
+await runMain(main)

src/routes/chat-completions/handler.ts

@@ -0,0 +1,68 @@
+import type { Context } from "hono"
+
+import consola from "consola"
+import { streamSSE, type SSEMessage } from "hono/streaming"
+
+import { awaitApproval } from "~/lib/approval"
+import { checkRateLimit } from "~/lib/rate-limit"
+import { state } from "~/lib/state"
+import { getTokenCount } from "~/lib/tokenizer"
+import { isNullish } from "~/lib/utils"
+import {
+  createChatCompletions,
+  type ChatCompletionResponse,
+  type ChatCompletionsPayload,
+} from "~/services/copilot/create-chat-completions"
+
+export async function handleCompletion(c: Context) {
+  await checkRateLimit(state)
+
+  let payload = await c.req.json<ChatCompletionsPayload>()
+  consola.debug("Request payload:", JSON.stringify(payload).slice(-400))
+
+  // Find the selected model
+  const selectedModel = state.models?.data.find(
+    (model) => model.id === payload.model,
+  )
+
+  // Calculate and display token count
+  try {
+    if (selectedModel) {
+      const tokenCount = await getTokenCount(payload, selectedModel)
+      consola.info("Current token count:", tokenCount)
+    } else {
+      consola.warn("No model selected, skipping token count calculation")
+    }
+  } catch (error) {
+    consola.warn("Failed to calculate token count:", error)
+  }
+
+  if (state.manualApprove) await awaitApproval()
+
+  if (isNullish(payload.max_tokens)) {
+    payload = {
+      ...payload,
+      max_tokens: selectedModel?.capabilities.limits.max_output_tokens,
+    }
+    consola.debug("Set max_tokens to:", JSON.stringify(payload.max_tokens))
+  }
+
+  const response = await createChatCompletions(payload)
+
+  if (isNonStreaming(response)) {
+    consola.debug("Non-streaming response:", JSON.stringify(response))
+    return c.json(response)
+  }
+
+  consola.debug("Streaming response")
+  return streamSSE(c, async (stream) => {
+    for await (const chunk of response) {
+      consola.debug("Streaming chunk:", JSON.stringify(chunk))
+      await stream.writeSSE(chunk as SSEMessage)
+    }
+  })
+}
+
+const isNonStreaming = (
+  response: Awaited<ReturnType<typeof createChatCompletions>>,
+): response is ChatCompletionResponse => Object.hasOwn(response, "choices")

src/routes/chat-completions/route.ts

@@ -0,0 +1,15 @@
+import { Hono } from "hono"
+
+import { forwardError } from "~/lib/error"
+
+import { handleCompletion } from "./handler"
+
+export const completionRoutes = new Hono()
+
+completionRoutes.post("/", async (c) => {
+  try {
+    return await handleCompletion(c)
+  } catch (error) {
+    return await forwardError(c, error)
+  }
+})

src/routes/embeddings/route.ts

@@ -0,0 +1,20 @@
+import { Hono } from "hono"
+
+import { forwardError } from "~/lib/error"
+import {
+  createEmbeddings,
+  type EmbeddingRequest,
+} from "~/services/copilot/create-embeddings"
+
+export const embeddingRoutes = new Hono()
+
+embeddingRoutes.post("/", async (c) => {
+  try {
+    const paylod = await c.req.json<EmbeddingRequest>()
+    const response = await createEmbeddings(paylod)
+
+    return c.json(response)
+  } catch (error) {
+    return await forwardError(c, error)
+  }
+})

src/routes/messages/anthropic-types.ts

@@ -0,0 +1,206 @@
+// Anthropic API Types
+
+export interface AnthropicMessagesPayload {
+  model: string
+  messages: Array<AnthropicMessage>
+  max_tokens: number
+  system?: string | Array<AnthropicTextBlock>
+  metadata?: {
+    user_id?: string
+  }
+  stop_sequences?: Array<string>
+  stream?: boolean
+  temperature?: number
+  top_p?: number
+  top_k?: number
+  tools?: Array<AnthropicTool>
+  tool_choice?: {
+    type: "auto" | "any" | "tool" | "none"
+    name?: string
+  }
+  thinking?: {
+    type: "enabled"
+    budget_tokens?: number
+  }
+  service_tier?: "auto" | "standard_only"
+}
+
+export interface AnthropicTextBlock {
+  type: "text"
+  text: string
+}
+
+export interface AnthropicImageBlock {
+  type: "image"
+  source: {
+    type: "base64"
+    media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp"
+    data: string
+  }
+}
+
+export interface AnthropicToolResultBlock {
+  type: "tool_result"
+  tool_use_id: string
+  content: string
+  is_error?: boolean
+}
+
+export interface AnthropicToolUseBlock {
+  type: "tool_use"
+  id: string
+  name: string
+  input: Record<string, unknown>
+}
+
+export interface AnthropicThinkingBlock {
+  type: "thinking"
+  thinking: string
+}
+
+export type AnthropicUserContentBlock =
+  | AnthropicTextBlock
+  | AnthropicImageBlock
+  | AnthropicToolResultBlock
+
+export type AnthropicAssistantContentBlock =
+  | AnthropicTextBlock
+  | AnthropicToolUseBlock
+  | AnthropicThinkingBlock
+
+export interface AnthropicUserMessage {
+  role: "user"
+  content: string | Array<AnthropicUserContentBlock>
+}
+
+export interface AnthropicAssistantMessage {
+  role: "assistant"
+  content: string | Array<AnthropicAssistantContentBlock>
+}
+
+export type AnthropicMessage = AnthropicUserMessage | AnthropicAssistantMessage
+
+export interface AnthropicTool {
+  name: string
+  description?: string
+  input_schema: Record<string, unknown>
+}
+
+export interface AnthropicResponse {
+  id: string
+  type: "message"
+  role: "assistant"
+  content: Array<AnthropicAssistantContentBlock>
+  model: string
+  stop_reason:
+    | "end_turn"
+    | "max_tokens"
+    | "stop_sequence"
+    | "tool_use"
+    | "pause_turn"
+    | "refusal"
+    | null
+  stop_sequence: string | null
+  usage: {
+    input_tokens: number
+    output_tokens: number
+    cache_creation_input_tokens?: number
+    cache_read_input_tokens?: number
+    service_tier?: "standard" | "priority" | "batch"
+  }
+}
+
+export type AnthropicResponseContentBlock = AnthropicAssistantContentBlock
+
+// Anthropic Stream Event Types
+export interface AnthropicMessageStartEvent {
+  type: "message_start"
+  message: Omit<
+    AnthropicResponse,
+    "content" | "stop_reason" | "stop_sequence"
+  > & {
+    content: []
+    stop_reason: null
+    stop_sequence: null
+  }
+}
+
+export interface AnthropicContentBlockStartEvent {
+  type: "content_block_start"
+  index: number
+  content_block:
+    | { type: "text"; text: string }
+    | (Omit<AnthropicToolUseBlock, "input"> & {
+        input: Record<string, unknown>
+      })
+    | { type: "thinking"; thinking: string }
+}
+
+export interface AnthropicContentBlockDeltaEvent {
+  type: "content_block_delta"
+  index: number
+  delta:
+    | { type: "text_delta"; text: string }
+    | { type: "input_json_delta"; partial_json: string }
+    | { type: "thinking_delta"; thinking: string }
+    | { type: "signature_delta"; signature: string }
+}
+
+export interface AnthropicContentBlockStopEvent {
+  type: "content_block_stop"
+  index: number
+}
+
+export interface AnthropicMessageDeltaEvent {
+  type: "message_delta"
+  delta: {
+    stop_reason?: AnthropicResponse["stop_reason"]
+    stop_sequence?: string | null
+  }
+  usage?: {
+    input_tokens?: number
+    output_tokens: number
+    cache_creation_input_tokens?: number
+    cache_read_input_tokens?: number
+  }
+}
+
+export interface AnthropicMessageStopEvent {
+  type: "message_stop"
+}
+
+export interface AnthropicPingEvent {
+  type: "ping"
+}
+
+export interface AnthropicErrorEvent {
+  type: "error"
+  error: {
+    type: string
+    message: string
+  }
+}
+
+export type AnthropicStreamEventData =
+  | AnthropicMessageStartEvent
+  | AnthropicContentBlockStartEvent
+  | AnthropicContentBlockDeltaEvent
+  | AnthropicContentBlockStopEvent
+  | AnthropicMessageDeltaEvent
+  | AnthropicMessageStopEvent
+  | AnthropicPingEvent
+  | AnthropicErrorEvent
+
+// State for streaming translation
+export interface AnthropicStreamState {
+  messageStartSent: boolean
+  contentBlockIndex: number
+  contentBlockOpen: boolean
+  toolCalls: {
+    [openAIToolIndex: number]: {
+      id: string
+      name: string
+      anthropicBlockIndex: number
+    }
+  }
+}

src/routes/messages/count-tokens-handler.ts

@@ -0,0 +1,70 @@
+import type { Context } from "hono"
+
+import consola from "consola"
+
+import { state } from "~/lib/state"
+import { getTokenCount } from "~/lib/tokenizer"
+
+import { type AnthropicMessagesPayload } from "./anthropic-types"
+import { translateToOpenAI } from "./non-stream-translation"
+
+/**
+ * Handles token counting for Anthropic messages
+ */
+export async function handleCountTokens(c: Context) {
+  try {
+    const anthropicBeta = c.req.header("anthropic-beta")
+
+    const anthropicPayload = await c.req.json<AnthropicMessagesPayload>()
+
+    const openAIPayload = translateToOpenAI(anthropicPayload)
+
+    const selectedModel = state.models?.data.find(
+      (model) => model.id === anthropicPayload.model,
+    )
+
+    if (!selectedModel) {
+      consola.warn("Model not found, returning default token count")
+      return c.json({
+        input_tokens: 1,
+      })
+    }
+
+    const tokenCount = await getTokenCount(openAIPayload, selectedModel)
+
+    if (anthropicPayload.tools && anthropicPayload.tools.length > 0) {
+      let mcpToolExist = false
+      if (anthropicBeta?.startsWith("claude-code")) {
+        mcpToolExist = anthropicPayload.tools.some((tool) =>
+          tool.name.startsWith("mcp__"),
+        )
+      }
+      if (!mcpToolExist) {
+        if (anthropicPayload.model.startsWith("claude")) {
+          // https://docs.anthropic.com/en/docs/agents-and-tools/tool-use/overview#pricing
+          tokenCount.input = tokenCount.input + 346
+        } else if (anthropicPayload.model.startsWith("grok")) {
+          tokenCount.input = tokenCount.input + 480
+        }
+      }
+    }
+
+    let finalTokenCount = tokenCount.input + tokenCount.output
+    if (anthropicPayload.model.startsWith("claude")) {
+      finalTokenCount = Math.round(finalTokenCount * 1.15)
+    } else if (anthropicPayload.model.startsWith("grok")) {
+      finalTokenCount = Math.round(finalTokenCount * 1.03)
+    }
+
+    consola.info("Token count:", finalTokenCount)
+
+    return c.json({
+      input_tokens: finalTokenCount,
+    })
+  } catch (error) {
+    consola.error("Error counting tokens:", error)
+    return c.json({
+      input_tokens: 1,
+    })
+  }
+}

src/routes/messages/handler.ts

@@ -0,0 +1,91 @@
+import type { Context } from "hono"
+
+import consola from "consola"
+import { streamSSE } from "hono/streaming"
+
+import { awaitApproval } from "~/lib/approval"
+import { checkRateLimit } from "~/lib/rate-limit"
+import { state } from "~/lib/state"
+import {
+  createChatCompletions,
+  type ChatCompletionChunk,
+  type ChatCompletionResponse,
+} from "~/services/copilot/create-chat-completions"
+
+import {
+  type AnthropicMessagesPayload,
+  type AnthropicStreamState,
+} from "./anthropic-types"
+import {
+  translateToAnthropic,
+  translateToOpenAI,
+} from "./non-stream-translation"
+import { translateChunkToAnthropicEvents } from "./stream-translation"
+
+export async function handleCompletion(c: Context) {
+  await checkRateLimit(state)
+
+  const anthropicPayload = await c.req.json<AnthropicMessagesPayload>()
+  consola.debug("Anthropic request payload:", JSON.stringify(anthropicPayload))
+
+  const openAIPayload = translateToOpenAI(anthropicPayload)
+  consola.debug(
+    "Translated OpenAI request payload:",
+    JSON.stringify(openAIPayload),
+  )
+
+  if (state.manualApprove) {
+    await awaitApproval()
+  }
+
+  const response = await createChatCompletions(openAIPayload)
+
+  if (isNonStreaming(response)) {
+    consola.debug(
+      "Non-streaming response from Copilot:",
+      JSON.stringify(response).slice(-400),
+    )
+    const anthropicResponse = translateToAnthropic(response)
+    consola.debug(
+      "Translated Anthropic response:",
+      JSON.stringify(anthropicResponse),
+    )
+    return c.json(anthropicResponse)
+  }
+
+  consola.debug("Streaming response from Copilot")
+  return streamSSE(c, async (stream) => {
+    const streamState: AnthropicStreamState = {
+      messageStartSent: false,
+      contentBlockIndex: 0,
+      contentBlockOpen: false,
+      toolCalls: {},
+    }
+
+    for await (const rawEvent of response) {
+      consola.debug("Copilot raw stream event:", JSON.stringify(rawEvent))
+      if (rawEvent.data === "[DONE]") {
+        break
+      }
+
+      if (!rawEvent.data) {
+        continue
+      }
+
+      const chunk = JSON.parse(rawEvent.data) as ChatCompletionChunk
+      const events = translateChunkToAnthropicEvents(chunk, streamState)
+
+      for (const event of events) {
+        consola.debug("Translated Anthropic event:", JSON.stringify(event))
+        await stream.writeSSE({
+          event: event.type,
+          data: JSON.stringify(event),
+        })
+      }
+    }
+  })
+}
+
+const isNonStreaming = (
+  response: Awaited<ReturnType<typeof createChatCompletions>>,
+): response is ChatCompletionResponse => Object.hasOwn(response, "choices")

src/routes/messages/non-stream-translation.ts

@@ -0,0 +1,357 @@
+import {
+  type ChatCompletionResponse,
+  type ChatCompletionsPayload,
+  type ContentPart,
+  type Message,
+  type TextPart,
+  type Tool,
+  type ToolCall,
+} from "~/services/copilot/create-chat-completions"
+
+import {
+  type AnthropicAssistantContentBlock,
+  type AnthropicAssistantMessage,
+  type AnthropicMessage,
+  type AnthropicMessagesPayload,
+  type AnthropicResponse,
+  type AnthropicTextBlock,
+  type AnthropicThinkingBlock,
+  type AnthropicTool,
+  type AnthropicToolResultBlock,
+  type AnthropicToolUseBlock,
+  type AnthropicUserContentBlock,
+  type AnthropicUserMessage,
+} from "./anthropic-types"
+import { mapOpenAIStopReasonToAnthropic } from "./utils"
+
+// Payload translation
+
+export function translateToOpenAI(
+  payload: AnthropicMessagesPayload,
+): ChatCompletionsPayload {
+  return {
+    model: translateModelName(payload.model),
+    messages: translateAnthropicMessagesToOpenAI(
+      payload.messages,
+      payload.system,
+    ),
+    max_tokens: payload.max_tokens,
+    stop: payload.stop_sequences,
+    stream: payload.stream,
+    temperature: payload.temperature,
+    top_p: payload.top_p,
+    user: payload.metadata?.user_id,
+    tools: translateAnthropicToolsToOpenAI(payload.tools),
+    tool_choice: translateAnthropicToolChoiceToOpenAI(payload.tool_choice),
+  }
+}
+
+function translateModelName(model: string): string {
+  // Subagent requests use a specific model number which Copilot doesn't support
+  if (model.startsWith("claude-sonnet-4-")) {
+    return model.replace(/^claude-sonnet-4-.*/, "claude-sonnet-4")
+  } else if (model.startsWith("claude-opus-")) {
+    return model.replace(/^claude-opus-4-.*/, "claude-opus-4")
+  }
+  return model
+}
+
+function translateAnthropicMessagesToOpenAI(
+  anthropicMessages: Array<AnthropicMessage>,
+  system: string | Array<AnthropicTextBlock> | undefined,
+): Array<Message> {
+  const systemMessages = handleSystemPrompt(system)
+
+  const otherMessages = anthropicMessages.flatMap((message) =>
+    message.role === "user" ?
+      handleUserMessage(message)
+    : handleAssistantMessage(message),
+  )
+
+  return [...systemMessages, ...otherMessages]
+}
+
+function handleSystemPrompt(
+  system: string | Array<AnthropicTextBlock> | undefined,
+): Array<Message> {
+  if (!system) {
+    return []
+  }
+
+  if (typeof system === "string") {
+    return [{ role: "system", content: system }]
+  } else {
+    const systemText = system.map((block) => block.text).join("\n\n")
+    return [{ role: "system", content: systemText }]
+  }
+}
+
+function handleUserMessage(message: AnthropicUserMessage): Array<Message> {
+  const newMessages: Array<Message> = []
+
+  if (Array.isArray(message.content)) {
+    const toolResultBlocks = message.content.filter(
+      (block): block is AnthropicToolResultBlock =>
+        block.type === "tool_result",
+    )
+    const otherBlocks = message.content.filter(
+      (block) => block.type !== "tool_result",
+    )
+
+    // Tool results must come first to maintain protocol: tool_use -> tool_result -> user
+    for (const block of toolResultBlocks) {
+      newMessages.push({
+        role: "tool",
+        tool_call_id: block.tool_use_id,
+        content: mapContent(block.content),
+      })
+    }
+
+    if (otherBlocks.length > 0) {
+      newMessages.push({
+        role: "user",
+        content: mapContent(otherBlocks),
+      })
+    }
+  } else {
+    newMessages.push({
+      role: "user",
+      content: mapContent(message.content),
+    })
+  }
+
+  return newMessages
+}
+
+function handleAssistantMessage(
+  message: AnthropicAssistantMessage,
+): Array<Message> {
+  if (!Array.isArray(message.content)) {
+    return [
+      {
+        role: "assistant",
+        content: mapContent(message.content),
+      },
+    ]
+  }
+
+  const toolUseBlocks = message.content.filter(
+    (block): block is AnthropicToolUseBlock => block.type === "tool_use",
+  )
+
+  const textBlocks = message.content.filter(
+    (block): block is AnthropicTextBlock => block.type === "text",
+  )
+
+  const thinkingBlocks = message.content.filter(
+    (block): block is AnthropicThinkingBlock => block.type === "thinking",
+  )
+
+  // Combine text and thinking blocks, as OpenAI doesn't have separate thinking blocks
+  const allTextContent = [
+    ...textBlocks.map((b) => b.text),
+    ...thinkingBlocks.map((b) => b.thinking),
+  ].join("\n\n")
+
+  return toolUseBlocks.length > 0 ?
+      [
+        {
+          role: "assistant",
+          content: allTextContent || null,
+          tool_calls: toolUseBlocks.map((toolUse) => ({
+            id: toolUse.id,
+            type: "function",
+            function: {
+              name: toolUse.name,
+              arguments: JSON.stringify(toolUse.input),
+            },
+          })),
+        },
+      ]
+    : [
+        {
+          role: "assistant",
+          content: mapContent(message.content),
+        },
+      ]
+}
+
+function mapContent(
+  content:
+    | string
+    | Array<AnthropicUserContentBlock | AnthropicAssistantContentBlock>,
+): string | Array<ContentPart> | null {
+  if (typeof content === "string") {
+    return content
+  }
+  if (!Array.isArray(content)) {
+    return null
+  }
+
+  const hasImage = content.some((block) => block.type === "image")
+  if (!hasImage) {
+    return content
+      .filter(
+        (block): block is AnthropicTextBlock | AnthropicThinkingBlock =>
+          block.type === "text" || block.type === "thinking",
+      )
+      .map((block) => (block.type === "text" ? block.text : block.thinking))
+      .join("\n\n")
+  }
+
+  const contentParts: Array<ContentPart> = []
+  for (const block of content) {
+    switch (block.type) {
+      case "text": {
+        contentParts.push({ type: "text", text: block.text })
+
+        break
+      }
+      case "thinking": {
+        contentParts.push({ type: "text", text: block.thinking })
+
+        break
+      }
+      case "image": {
+        contentParts.push({
+          type: "image_url",
+          image_url: {
+            url: `data:${block.source.media_type};base64,${block.source.data}`,
+          },
+        })
+
+        break
+      }
+      // No default
+    }
+  }
+  return contentParts
+}
+
+function translateAnthropicToolsToOpenAI(
+  anthropicTools: Array<AnthropicTool> | undefined,
+): Array<Tool> | undefined {
+  if (!anthropicTools) {
+    return undefined
+  }
+  return anthropicTools.map((tool) => ({
+    type: "function",
+    function: {
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.input_schema,
+    },
+  }))
+}
+
+function translateAnthropicToolChoiceToOpenAI(
+  anthropicToolChoice: AnthropicMessagesPayload["tool_choice"],
+): ChatCompletionsPayload["tool_choice"] {
+  if (!anthropicToolChoice) {
+    return undefined
+  }
+
+  switch (anthropicToolChoice.type) {
+    case "auto": {
+      return "auto"
+    }
+    case "any": {
+      return "required"
+    }
+    case "tool": {
+      if (anthropicToolChoice.name) {
+        return {
+          type: "function",
+          function: { name: anthropicToolChoice.name },
+        }
+      }
+      return undefined
+    }
+    case "none": {
+      return "none"
+    }
+    default: {
+      return undefined
+    }
+  }
+}
+
+// Response translation
+
+export function translateToAnthropic(
+  response: ChatCompletionResponse,
+): AnthropicResponse {
+  // Merge content from all choices
+  const allTextBlocks: Array<AnthropicTextBlock> = []
+  const allToolUseBlocks: Array<AnthropicToolUseBlock> = []
+  let stopReason: "stop" | "length" | "tool_calls" | "content_filter" | null =
+    null // default
+  stopReason = response.choices[0]?.finish_reason ?? stopReason
+
+  // Process all choices to extract text and tool use blocks
+  for (const choice of response.choices) {
+    const textBlocks = getAnthropicTextBlocks(choice.message.content)
+    const toolUseBlocks = getAnthropicToolUseBlocks(choice.message.tool_calls)
+
+    allTextBlocks.push(...textBlocks)
+    allToolUseBlocks.push(...toolUseBlocks)
+
+    // Use the finish_reason from the first choice, or prioritize tool_calls
+    if (choice.finish_reason === "tool_calls" || stopReason === "stop") {
+      stopReason = choice.finish_reason
+    }
+  }
+
+  // Note: GitHub Copilot doesn't generate thinking blocks, so we don't include them in responses
+
+  return {
+    id: response.id,
+    type: "message",
+    role: "assistant",
+    model: response.model,
+    content: [...allTextBlocks, ...allToolUseBlocks],
+    stop_reason: mapOpenAIStopReasonToAnthropic(stopReason),
+    stop_sequence: null,
+    usage: {
+      input_tokens:
+        (response.usage?.prompt_tokens ?? 0)
+        - (response.usage?.prompt_tokens_details?.cached_tokens ?? 0),
+      output_tokens: response.usage?.completion_tokens ?? 0,
+      ...(response.usage?.prompt_tokens_details?.cached_tokens
+        !== undefined && {
+        cache_read_input_tokens:
+          response.usage.prompt_tokens_details.cached_tokens,
+      }),
+    },
+  }
+}
+
+function getAnthropicTextBlocks(
+  messageContent: Message["content"],
+): Array<AnthropicTextBlock> {
+  if (typeof messageContent === "string") {
+    return [{ type: "text", text: messageContent }]
+  }
+
+  if (Array.isArray(messageContent)) {
+    return messageContent
+      .filter((part): part is TextPart => part.type === "text")
+      .map((part) => ({ type: "text", text: part.text }))
+  }
+
+  return []
+}
+
+function getAnthropicToolUseBlocks(
+  toolCalls: Array<ToolCall> | undefined,
+): Array<AnthropicToolUseBlock> {
+  if (!toolCalls) {
+    return []
+  }
+  return toolCalls.map((toolCall) => ({
+    type: "tool_use",
+    id: toolCall.id,
+    name: toolCall.function.name,
+    input: JSON.parse(toolCall.function.arguments) as Record<string, unknown>,
+  }))
+}

src/routes/messages/route.ts

@@ -0,0 +1,24 @@
+import { Hono } from "hono"
+
+import { forwardError } from "~/lib/error"
+
+import { handleCountTokens } from "./count-tokens-handler"
+import { handleCompletion } from "./handler"
+
+export const messageRoutes = new Hono()
+
+messageRoutes.post("/", async (c) => {
+  try {
+    return await handleCompletion(c)
+  } catch (error) {
+    return await forwardError(c, error)
+  }
+})
+
+messageRoutes.post("/count_tokens", async (c) => {
+  try {
+    return await handleCountTokens(c)
+  } catch (error) {
+    return await forwardError(c, error)
+  }
+})

src/routes/messages/stream-translation.ts

@@ -0,0 +1,190 @@
+import { type ChatCompletionChunk } from "~/services/copilot/create-chat-completions"
+
+import {
+  type AnthropicStreamEventData,
+  type AnthropicStreamState,
+} from "./anthropic-types"
+import { mapOpenAIStopReasonToAnthropic } from "./utils"
+
+function isToolBlockOpen(state: AnthropicStreamState): boolean {
+  if (!state.contentBlockOpen) {
+    return false
+  }
+  // Check if the current block index corresponds to any known tool call
+  return Object.values(state.toolCalls).some(
+    (tc) => tc.anthropicBlockIndex === state.contentBlockIndex,
+  )
+}
+
+// eslint-disable-next-line max-lines-per-function, complexity
+export function translateChunkToAnthropicEvents(
+  chunk: ChatCompletionChunk,
+  state: AnthropicStreamState,
+): Array<AnthropicStreamEventData> {
+  const events: Array<AnthropicStreamEventData> = []
+
+  if (chunk.choices.length === 0) {
+    return events
+  }
+
+  const choice = chunk.choices[0]
+  const { delta } = choice
+
+  if (!state.messageStartSent) {
+    events.push({
+      type: "message_start",
+      message: {
+        id: chunk.id,
+        type: "message",
+        role: "assistant",
+        content: [],
+        model: chunk.model,
+        stop_reason: null,
+        stop_sequence: null,
+        usage: {
+          input_tokens:
+            (chunk.usage?.prompt_tokens ?? 0)
+            - (chunk.usage?.prompt_tokens_details?.cached_tokens ?? 0),
+          output_tokens: 0, // Will be updated in message_delta when finished
+          ...(chunk.usage?.prompt_tokens_details?.cached_tokens
+            !== undefined && {
+            cache_read_input_tokens:
+              chunk.usage.prompt_tokens_details.cached_tokens,
+          }),
+        },
+      },
+    })
+    state.messageStartSent = true
+  }
+
+  if (delta.content) {
+    if (isToolBlockOpen(state)) {
+      // A tool block was open, so close it before starting a text block.
+      events.push({
+        type: "content_block_stop",
+        index: state.contentBlockIndex,
+      })
+      state.contentBlockIndex++
+      state.contentBlockOpen = false
+    }
+
+    if (!state.contentBlockOpen) {
+      events.push({
+        type: "content_block_start",
+        index: state.contentBlockIndex,
+        content_block: {
+          type: "text",
+          text: "",
+        },
+      })
+      state.contentBlockOpen = true
+    }
+
+    events.push({
+      type: "content_block_delta",
+      index: state.contentBlockIndex,
+      delta: {
+        type: "text_delta",
+        text: delta.content,
+      },
+    })
+  }
+
+  if (delta.tool_calls) {
+    for (const toolCall of delta.tool_calls) {
+      if (toolCall.id && toolCall.function?.name) {
+        // New tool call starting.
+        if (state.contentBlockOpen) {
+          // Close any previously open block.
+          events.push({
+            type: "content_block_stop",
+            index: state.contentBlockIndex,
+          })
+          state.contentBlockIndex++
+          state.contentBlockOpen = false
+        }
+
+        const anthropicBlockIndex = state.contentBlockIndex
+        state.toolCalls[toolCall.index] = {
+          id: toolCall.id,
+          name: toolCall.function.name,
+          anthropicBlockIndex,
+        }
+
+        events.push({
+          type: "content_block_start",
+          index: anthropicBlockIndex,
+          content_block: {
+            type: "tool_use",
+            id: toolCall.id,
+            name: toolCall.function.name,
+            input: {},
+          },
+        })
+        state.contentBlockOpen = true
+      }
+
+      if (toolCall.function?.arguments) {
+        const toolCallInfo = state.toolCalls[toolCall.index]
+        // Tool call can still be empty
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        if (toolCallInfo) {
+          events.push({
+            type: "content_block_delta",
+            index: toolCallInfo.anthropicBlockIndex,
+            delta: {
+              type: "input_json_delta",
+              partial_json: toolCall.function.arguments,
+            },
+          })
+        }
+      }
+    }
+  }
+
+  if (choice.finish_reason) {
+    if (state.contentBlockOpen) {
+      events.push({
+        type: "content_block_stop",
+        index: state.contentBlockIndex,
+      })
+      state.contentBlockOpen = false
+    }
+
+    events.push(
+      {
+        type: "message_delta",
+        delta: {
+          stop_reason: mapOpenAIStopReasonToAnthropic(choice.finish_reason),
+          stop_sequence: null,
+        },
+        usage: {
+          input_tokens:
+            (chunk.usage?.prompt_tokens ?? 0)
+            - (chunk.usage?.prompt_tokens_details?.cached_tokens ?? 0),
+          output_tokens: chunk.usage?.completion_tokens ?? 0,
+          ...(chunk.usage?.prompt_tokens_details?.cached_tokens
+            !== undefined && {
+            cache_read_input_tokens:
+              chunk.usage.prompt_tokens_details.cached_tokens,
+          }),
+        },
+      },
+      {
+        type: "message_stop",
+      },
+    )
+  }
+
+  return events
+}
+
+export function translateErrorToAnthropicErrorEvent(): AnthropicStreamEventData {
+  return {
+    type: "error",
+    error: {
+      type: "api_error",
+      message: "An unexpected error occurred during streaming.",
+    },
+  }
+}

src/routes/messages/utils.ts

@@ -0,0 +1,16 @@
+import { type AnthropicResponse } from "./anthropic-types"
+
+export function mapOpenAIStopReasonToAnthropic(
+  finishReason: "stop" | "length" | "tool_calls" | "content_filter" | null,
+): AnthropicResponse["stop_reason"] {
+  if (finishReason === null) {
+    return null
+  }
+  const stopReasonMap = {
+    stop: "end_turn",
+    length: "max_tokens",
+    tool_calls: "tool_use",
+    content_filter: "end_turn",
+  } as const
+  return stopReasonMap[finishReason]
+}

src/routes/models/route.ts

@@ -0,0 +1,34 @@
+import { Hono } from "hono"
+
+import { forwardError } from "~/lib/error"
+import { state } from "~/lib/state"
+import { cacheModels } from "~/lib/utils"
+
+export const modelRoutes = new Hono()
+
+modelRoutes.get("/", async (c) => {
+  try {
+    if (!state.models) {
+      // This should be handled by startup logic, but as a fallback.
+      await cacheModels()
+    }
+
+    const models = state.models?.data.map((model) => ({
+      id: model.id,
+      object: "model",
+      type: "model",
+      created: 0, // No date available from source
+      created_at: new Date(0).toISOString(), // No date available from source
+      owned_by: model.vendor,
+      display_name: model.name,
+    }))
+
+    return c.json({
+      object: "list",
+      data: models,
+      has_more: false,
+    })
+  } catch (error) {
+    return await forwardError(c, error)
+  }
+})

src/routes/token/route.ts

@@ -0,0 +1,16 @@
+import { Hono } from "hono"
+
+import { state } from "~/lib/state"
+
+export const tokenRoute = new Hono()
+
+tokenRoute.get("/", (c) => {
+  try {
+    return c.json({
+      token: state.copilotToken,
+    })
+  } catch (error) {
+    console.error("Error fetching token:", error)
+    return c.json({ error: "Failed to fetch token", token: null }, 500)
+  }
+})

src/routes/usage/route.ts

@@ -0,0 +1,15 @@
+import { Hono } from "hono"
+
+import { getCopilotUsage } from "~/services/github/get-copilot-usage"
+
+export const usageRoute = new Hono()
+
+usageRoute.get("/", async (c) => {
+  try {
+    const usage = await getCopilotUsage()
+    return c.json(usage)
+  } catch (error) {
+    console.error("Error fetching Copilot usage:", error)
+    return c.json({ error: "Failed to fetch Copilot usage" }, 500)
+  }
+})

src/server.ts

@@ -0,0 +1,31 @@
+import { Hono } from "hono"
+import { cors } from "hono/cors"
+import { logger } from "hono/logger"
+
+import { completionRoutes } from "./routes/chat-completions/route"
+import { embeddingRoutes } from "./routes/embeddings/route"
+import { messageRoutes } from "./routes/messages/route"
+import { modelRoutes } from "./routes/models/route"
+import { tokenRoute } from "./routes/token/route"
+import { usageRoute } from "./routes/usage/route"
+
+export const server = new Hono()
+
+server.use(logger())
+server.use(cors())
+
+server.get("/", (c) => c.text("Server running"))
+
+server.route("/chat/completions", completionRoutes)
+server.route("/models", modelRoutes)
+server.route("/embeddings", embeddingRoutes)
+server.route("/usage", usageRoute)
+server.route("/token", tokenRoute)
+
+// Compatibility with tools that expect v1/ prefix
+server.route("/v1/chat/completions", completionRoutes)
+server.route("/v1/models", modelRoutes)
+server.route("/v1/embeddings", embeddingRoutes)
+
+// Anthropic compatible endpoints
+server.route("/v1/messages", messageRoutes)

src/services/copilot/create-chat-completions.ts

@@ -0,0 +1,193 @@
+import consola from "consola"
+import { events } from "fetch-event-stream"
+
+import { copilotHeaders, copilotBaseUrl } from "~/lib/api-config"
+import { HTTPError } from "~/lib/error"
+import { state } from "~/lib/state"
+
+export const createChatCompletions = async (
+  payload: ChatCompletionsPayload,
+) => {
+  if (!state.copilotToken) throw new Error("Copilot token not found")
+
+  const enableVision = payload.messages.some(
+    (x) =>
+      typeof x.content !== "string"
+      && x.content?.some((x) => x.type === "image_url"),
+  )
+
+  // Agent/user check for X-Initiator header
+  // Determine if any message is from an agent ("assistant" or "tool")
+  const isAgentCall = payload.messages.some((msg) =>
+    ["assistant", "tool"].includes(msg.role),
+  )
+
+  // Build headers and add X-Initiator
+  const headers: Record<string, string> = {
+    ...copilotHeaders(state, enableVision),
+    "X-Initiator": isAgentCall ? "agent" : "user",
+  }
+
+  const response = await fetch(`${copilotBaseUrl(state)}/chat/completions`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(payload),
+  })
+
+  if (!response.ok) {
+    consola.error("Failed to create chat completions", response)
+    throw new HTTPError("Failed to create chat completions", response)
+  }
+
+  if (payload.stream) {
+    return events(response)
+  }
+
+  return (await response.json()) as ChatCompletionResponse
+}
+
+// Streaming types
+
+export interface ChatCompletionChunk {
+  id: string
+  object: "chat.completion.chunk"
+  created: number
+  model: string
+  choices: Array<Choice>
+  system_fingerprint?: string
+  usage?: {
+    prompt_tokens: number
+    completion_tokens: number
+    total_tokens: number
+    prompt_tokens_details?: {
+      cached_tokens: number
+    }
+    completion_tokens_details?: {
+      accepted_prediction_tokens: number
+      rejected_prediction_tokens: number
+    }
+  }
+}
+
+interface Delta {
+  content?: string | null
+  role?: "user" | "assistant" | "system" | "tool"
+  tool_calls?: Array<{
+    index: number
+    id?: string
+    type?: "function"
+    function?: {
+      name?: string
+      arguments?: string
+    }
+  }>
+}
+
+interface Choice {
+  index: number
+  delta: Delta
+  finish_reason: "stop" | "length" | "tool_calls" | "content_filter" | null
+  logprobs: object | null
+}
+
+// Non-streaming types
+
+export interface ChatCompletionResponse {
+  id: string
+  object: "chat.completion"
+  created: number
+  model: string
+  choices: Array<ChoiceNonStreaming>
+  system_fingerprint?: string
+  usage?: {
+    prompt_tokens: number
+    completion_tokens: number
+    total_tokens: number
+    prompt_tokens_details?: {
+      cached_tokens: number
+    }
+  }
+}
+
+interface ResponseMessage {
+  role: "assistant"
+  content: string | null
+  tool_calls?: Array<ToolCall>
+}
+
+interface ChoiceNonStreaming {
+  index: number
+  message: ResponseMessage
+  logprobs: object | null
+  finish_reason: "stop" | "length" | "tool_calls" | "content_filter"
+}
+
+// Payload types
+
+export interface ChatCompletionsPayload {
+  messages: Array<Message>
+  model: string
+  temperature?: number | null
+  top_p?: number | null
+  max_tokens?: number | null
+  stop?: string | Array<string> | null
+  n?: number | null
+  stream?: boolean | null
+
+  frequency_penalty?: number | null
+  presence_penalty?: number | null
+  logit_bias?: Record<string, number> | null
+  logprobs?: boolean | null
+  response_format?: { type: "json_object" } | null
+  seed?: number | null
+  tools?: Array<Tool> | null
+  tool_choice?:
+    | "none"
+    | "auto"
+    | "required"
+    | { type: "function"; function: { name: string } }
+    | null
+  user?: string | null
+}
+
+export interface Tool {
+  type: "function"
+  function: {
+    name: string
+    description?: string
+    parameters: Record<string, unknown>
+  }
+}
+
+export interface Message {
+  role: "user" | "assistant" | "system" | "tool" | "developer"
+  content: string | Array<ContentPart> | null
+
+  name?: string
+  tool_calls?: Array<ToolCall>
+  tool_call_id?: string
+}
+
+export interface ToolCall {
+  id: string
+  type: "function"
+  function: {
+    name: string
+    arguments: string
+  }
+}
+
+export type ContentPart = TextPart | ImagePart
+
+export interface TextPart {
+  type: "text"
+  text: string
+}
+
+export interface ImagePart {
+  type: "image_url"
+  image_url: {
+    url: string
+    detail?: "low" | "high" | "auto"
+  }
+}

src/services/copilot/create-embeddings.ts

@@ -0,0 +1,38 @@
+import { copilotHeaders, copilotBaseUrl } from "~/lib/api-config"
+import { HTTPError } from "~/lib/error"
+import { state } from "~/lib/state"
+
+export const createEmbeddings = async (payload: EmbeddingRequest) => {
+  if (!state.copilotToken) throw new Error("Copilot token not found")
+
+  const response = await fetch(`${copilotBaseUrl(state)}/embeddings`, {
+    method: "POST",
+    headers: copilotHeaders(state),
+    body: JSON.stringify(payload),
+  })
+
+  if (!response.ok) throw new HTTPError("Failed to create embeddings", response)
+
+  return (await response.json()) as EmbeddingResponse
+}
+
+export interface EmbeddingRequest {
+  input: string | Array<string>
+  model: string
+}
+
+export interface Embedding {
+  object: string
+  embedding: Array<number>
+  index: number
+}
+
+export interface EmbeddingResponse {
+  object: string
+  data: Array<Embedding>
+  model: string
+  usage: {
+    prompt_tokens: number
+    total_tokens: number
+  }
+}

src/services/copilot/get-models.ts

@@ -0,0 +1,55 @@
+import { copilotBaseUrl, copilotHeaders } from "~/lib/api-config"
+import { HTTPError } from "~/lib/error"
+import { state } from "~/lib/state"
+
+export const getModels = async () => {
+  const response = await fetch(`${copilotBaseUrl(state)}/models`, {
+    headers: copilotHeaders(state),
+  })
+
+  if (!response.ok) throw new HTTPError("Failed to get models", response)
+
+  return (await response.json()) as ModelsResponse
+}
+
+export interface ModelsResponse {
+  data: Array<Model>
+  object: string
+}
+
+interface ModelLimits {
+  max_context_window_tokens?: number
+  max_output_tokens?: number
+  max_prompt_tokens?: number
+  max_inputs?: number
+}
+
+interface ModelSupports {
+  tool_calls?: boolean
+  parallel_tool_calls?: boolean
+  dimensions?: boolean
+}
+
+interface ModelCapabilities {
+  family: string
+  limits: ModelLimits
+  object: string
+  supports: ModelSupports
+  tokenizer: string
+  type: string
+}
+
+export interface Model {
+  capabilities: ModelCapabilities
+  id: string
+  model_picker_enabled: boolean
+  name: string
+  object: string
+  preview: boolean
+  vendor: string
+  version: string
+  policy?: {
+    state: string
+    terms: string
+  }
+}