Initial upload from Google 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,23 @@
+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 7860
+
+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.

entrypoint.sh

@@ -0,0 +1,12 @@
+#!/bin/sh
+
+PORT=${PORT:-7860}
+
+if [ "$1" = "--auth" ]; then
+  exec bun run dist/main.js auth
+else
+  exec bun run dist/main.js start \
+    -g "$GH_TOKEN" \
+    --port $PORT \
+    --host 0.0.0.0
+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 <erickchristian48@gmail.com>",
+  "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/lucide-react@0.378.0/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
+  }
+}

src/services/get-vscode-version.ts

@@ -0,0 +1,33 @@
+const FALLBACK = "1.104.3"
+
+export async function getVSCodeVersion() {
+  const controller = new AbortController()
+  const timeout = setTimeout(() => {
+    controller.abort()
+  }, 5000)
+
+  try {
+    const response = await fetch(
+      "https://aur.archlinux.org/cgit/aur.git/plain/PKGBUILD?h=visual-studio-code-bin",
+      {
+        signal: controller.signal,
+      },
+    )
+
+    const pkgbuild = await response.text()
+    const pkgverRegex = /pkgver=([0-9.]+)/
+    const match = pkgbuild.match(pkgverRegex)
+
+    if (match) {
+      return match[1]
+    }
+
+    return FALLBACK
+  } catch {
+    return FALLBACK
+  } finally {
+    clearTimeout(timeout)
+  }
+}
+
+await getVSCodeVersion()