feat: add thinking support, enterprise URLs, and Prometheus metrics

Phase 4 implementation from upstream PRs:

- PR ericc-ch#167: Claude thinking/reasoning support with thinking block extraction
- PR ericc-ch#128: GitHub Enterprise Server/Cloud support with --enterprise-url option
- PR ericc-ch#132: Prometheus metrics endpoint at /metrics for Grafana monitoring

Changes:
- Add reasoning_text/reasoning_opaque to ResponseMessage type
- Extract thinking blocks from Claude responses
- New src/lib/url.ts for enterprise URL helpers
- Convert static GitHub URLs to dynamic getGitHubApiBaseUrl/getGitHubBaseUrl
- Update all GitHub service files for enterprise support
- Add --enterprise-url/-e CLI option
- New src/lib/metrics.ts MetricsCollector class
- New /metrics route for Prometheus format output
- Instrument chat-completions, messages, responses handlers with metrics

Co-authored-by: caozhiyuan <caozhiyuan@users.noreply.github.com>
Co-authored-by: jkorsvik <jkorsvik@users.noreply.github.com>
Co-authored-by: luisbrandao <luisbrandao@users.noreply.github.com>
Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: 5 people

package-lock.json

@@ -36,7 +36,8 @@ export const copilotHeaders = (state: State, vision: boolean = false) => {
   return headers
 }
 
-export const GITHUB_API_BASE_URL = "https://api.github.com"
+// PR #128: Use dynamic URL functions for Enterprise support (@jkorsvik)
+
 export const githubHeaders = (state: State) => ({
   ...standardHeaders(),
   authorization: `token ${state.githubToken}`,
@@ -47,6 +48,10 @@ export const githubHeaders = (state: State) => ({
   "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(" ")
+
+export {
+  githubApiBaseUrl as getGitHubApiBaseUrl,
+  githubBaseUrl as getGitHubBaseUrl,
+} from "./url"

src/lib/api-config.ts

@@ -0,0 +1,133 @@
+/**
+ * Prometheus Metrics
+ * PR #132: Add Prometheus support (@luisbrandao)
+ *
+ * Provides a simple metrics collection system for Grafana monitoring.
+ * Tracks request counts, latencies, and token usage.
+ */
+
+interface RequestMetric {
+  endpoint: string
+  method: string
+  status: number
+  model?: string
+  latencyMs: number
+  inputTokens?: number
+  outputTokens?: number
+  timestamp: number
+}
+
+class MetricsCollector {
+  private requests: Array<RequestMetric> = []
+  private readonly maxHistorySize = 10000
+
+  recordRequest(metric: RequestMetric): void {
+    this.requests.push(metric)
+    // Trim old entries if we exceed max size
+    if (this.requests.length > this.maxHistorySize) {
+      this.requests = this.requests.slice(-this.maxHistorySize)
+    }
+  }
+
+  getPrometheusMetrics(): string {
+    const lines: Array<string> = []
+
+    // Request count by endpoint and status
+    const requestCounts = new Map<string, number>()
+    const latencySums = new Map<string, number>()
+    const latencyCounts = new Map<string, number>()
+    const tokenInputSums = new Map<string, number>()
+    const tokenOutputSums = new Map<string, number>()
+
+    for (const req of this.requests) {
+      const key = `endpoint="${req.endpoint}",method="${req.method}",status="${req.status}"`
+      requestCounts.set(key, (requestCounts.get(key) ?? 0) + 1)
+      latencySums.set(key, (latencySums.get(key) ?? 0) + req.latencyMs)
+      latencyCounts.set(key, (latencyCounts.get(key) ?? 0) + 1)
+
+      if (req.model) {
+        const modelKey = `model="${req.model}"`
+        if (req.inputTokens) {
+          tokenInputSums.set(
+            modelKey,
+            (tokenInputSums.get(modelKey) ?? 0) + req.inputTokens,
+          )
+        }
+        if (req.outputTokens) {
+          tokenOutputSums.set(
+            modelKey,
+            (tokenOutputSums.get(modelKey) ?? 0) + req.outputTokens,
+          )
+        }
+      }
+    }
+
+    // Output metrics in Prometheus format
+    lines.push(
+      "# HELP copilot_api_requests_total Total number of API requests",
+      "# TYPE copilot_api_requests_total counter",
+    )
+    for (const [key, count] of requestCounts) {
+      lines.push(`copilot_api_requests_total{${key}} ${count}`)
+    }
+
+    lines.push(
+      "",
+      "# HELP copilot_api_request_latency_ms_sum Sum of request latencies in milliseconds",
+      "# TYPE copilot_api_request_latency_ms_sum counter",
+    )
+    for (const [key, sum] of latencySums) {
+      lines.push(`copilot_api_request_latency_ms_sum{${key}} ${sum}`)
+    }
+
+    lines.push(
+      "",
+      "# HELP copilot_api_request_latency_ms_count Count of requests for latency calculation",
+      "# TYPE copilot_api_request_latency_ms_count counter",
+    )
+    for (const [key, count] of latencyCounts) {
+      lines.push(`copilot_api_request_latency_ms_count{${key}} ${count}`)
+    }
+
+    lines.push(
+      "",
+      "# HELP copilot_api_tokens_input_total Total input tokens by model",
+      "# TYPE copilot_api_tokens_input_total counter",
+    )
+    for (const [key, sum] of tokenInputSums) {
+      lines.push(`copilot_api_tokens_input_total{${key}} ${sum}`)
+    }
+
+    lines.push(
+      "",
+      "# HELP copilot_api_tokens_output_total Total output tokens by model",
+      "# TYPE copilot_api_tokens_output_total counter",
+    )
+    for (const [key, sum] of tokenOutputSums) {
+      lines.push(`copilot_api_tokens_output_total{${key}} ${sum}`)
+    }
+
+    return lines.join("\n")
+  }
+
+  getStats(): {
+    totalRequests: number
+    successRate: number
+    avgLatencyMs: number
+  } {
+    if (this.requests.length === 0) {
+      return { totalRequests: 0, successRate: 0, avgLatencyMs: 0 }
+    }
+
+    const successful = this.requests.filter((r) => r.status < 400).length
+    const totalLatency = this.requests.reduce((sum, r) => sum + r.latencyMs, 0)
+
+    return {
+      totalRequests: this.requests.length,
+      successRate: successful / this.requests.length,
+      avgLatencyMs: totalLatency / this.requests.length,
+    }
+  }
+}
+
+export const metrics = new MetricsCollector()

src/lib/metrics.ts

@@ -5,15 +5,19 @@ 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")
+// PR #128: GitHub Enterprise support (@jkorsvik)
+const ENTERPRISE_URL_PATH = path.join(APP_DIR, "enterprise_url")
 
 export const PATHS = {
   APP_DIR,
   GITHUB_TOKEN_PATH,
+  ENTERPRISE_URL_PATH,
 }
 
 export async function ensurePaths(): Promise<void> {
   await fs.mkdir(PATHS.APP_DIR, { recursive: true })
   await ensureFile(PATHS.GITHUB_TOKEN_PATH)
+  await ensureFile(PATHS.ENTERPRISE_URL_PATH)
 }
 
 async function ensureFile(filePath: string): Promise<void> {

src/lib/paths.ts

@@ -18,6 +18,9 @@ export interface State {
 
   // PR #144: API key authentication (@ZiuChen)
   apiKeys?: Array<string>
+
+  // PR #128: GitHub Enterprise support (@jkorsvik)
+  enterpriseUrl?: string
 }
 
 export const state: State = {

src/lib/state.ts

@@ -0,0 +1,43 @@
+/**
+ * URL Helpers for GitHub Enterprise Support
+ * PR #128: Add GitHub Enterprise Server/Cloud support (@jkorsvik)
+ *
+ * Provides functions to normalize URLs and determine API endpoints
+ * for both github.com and enterprise instances.
+ */
+
+import { state } from "./state"
+
+/**
+ * Normalizes a domain by stripping protocol and trailing slashes
+ * @example normalizeDomain("https://github.example.com/") => "github.example.com"
+ */
+export function normalizeDomain(url: string): string {
+  return url
+    .replace(/^https?:\/\//, "")
+    .replace(/\/+$/, "")
+    .toLowerCase()
+}
+
+/**
+ * Returns the base GitHub URL for OAuth endpoints
+ * @returns github.com or the enterprise domain
+ */
+export function githubBaseUrl(): string {
+  if (state.enterpriseUrl) {
+    return `https://${normalizeDomain(state.enterpriseUrl)}`
+  }
+  return "https://github.com"
+}
+
+/**
+ * Returns the GitHub API base URL
+ * @returns api.github.com or api.{enterprise}
+ */
+export function githubApiBaseUrl(): string {
+  if (state.enterpriseUrl) {
+    const domain = normalizeDomain(state.enterpriseUrl)
+    return `https://api.${domain}`
+  }
+  return "https://api.github.com"
+}

src/lib/url.ts

@@ -4,6 +4,7 @@ import consola from "consola"
 import { streamSSE, type SSEMessage } from "hono/streaming"
 
 import { awaitApproval } from "~/lib/approval"
+import { metrics } from "~/lib/metrics"
 import { checkRateLimit } from "~/lib/rate-limit"
 import { state } from "~/lib/state"
 import { getTokenCount } from "~/lib/tokenizer"
@@ -15,6 +16,7 @@ import {
 } from "~/services/copilot/create-chat-completions"
 
 export async function handleCompletion(c: Context) {
+  const startTime = Date.now()
   await checkRateLimit(state)
 
   let payload = await c.req.json<ChatCompletionsPayload>()
@@ -51,6 +53,14 @@ export async function handleCompletion(c: Context) {
 
   if (isNonStreaming(response)) {
     consola.debug("Non-streaming response:", JSON.stringify(response))
+    const latency = Date.now() - startTime
+    metrics.recordRequest(
+      "/chat/completions",
+      "POST",
+      200,
+      payload.model,
+      latency,
+    )
     // Add object type for pydantic_ai compatibility (PR #185 by @Vincenthays)
     return c.json({ ...response, object: "chat.completion" })
   }
@@ -61,6 +71,14 @@ export async function handleCompletion(c: Context) {
       consola.debug("Streaming chunk:", JSON.stringify(chunk))
       await stream.writeSSE(chunk as SSEMessage)
     }
+    const latency = Date.now() - startTime
+    metrics.recordRequest(
+      "/chat/completions",
+      "POST",
+      200,
+      payload.model,
+      latency,
+    )
   })
 }
 

src/routes/chat-completions/handler.ts

@@ -4,6 +4,7 @@ import consola from "consola"
 import { streamSSE } from "hono/streaming"
 
 import { awaitApproval } from "~/lib/approval"
+import { metrics } from "~/lib/metrics"
 import { checkRateLimit } from "~/lib/rate-limit"
 import { state } from "~/lib/state"
 import {
@@ -23,6 +24,7 @@ import {
 import { translateChunkToAnthropicEvents } from "./stream-translation"
 
 export async function handleCompletion(c: Context) {
+  const startTime = Date.now()
   await checkRateLimit(state)
 
   const anthropicPayload = await c.req.json<AnthropicMessagesPayload>()
@@ -50,6 +52,14 @@ export async function handleCompletion(c: Context) {
       "Translated Anthropic response:",
       JSON.stringify(anthropicResponse),
     )
+    const latency = Date.now() - startTime
+    metrics.recordRequest(
+      "/v1/messages",
+      "POST",
+      200,
+      anthropicPayload.model,
+      latency,
+    )
     return c.json(anthropicResponse)
   }
 
@@ -83,6 +93,14 @@ export async function handleCompletion(c: Context) {
         })
       }
     }
+    const latency = Date.now() - startTime
+    metrics.recordRequest(
+      "/v1/messages",
+      "POST",
+      200,
+      anthropicPayload.model,
+      latency,
+    )
   })
 }
 

src/routes/messages/handler.ts

@@ -3,6 +3,7 @@ import {
   type ChatCompletionsPayload,
   type ContentPart,
   type Message,
+  type ResponseMessage,
   type TextPart,
   type Tool,
   type ToolCall,
@@ -313,17 +314,21 @@ export function translateToAnthropic(
   response: ChatCompletionResponse,
 ): AnthropicResponse {
   // Merge content from all choices
+  const allThinkingBlocks: Array<AnthropicThinkingBlock> = []
   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
+  // Process all choices to extract text, thinking, and tool use blocks
   for (const choice of response.choices) {
+    // PR #167: Extract thinking blocks from reasoning fields (@caozhiyuan)
+    const thinkingBlocks = getAnthropicThinkingBlocks(choice.message)
     const textBlocks = getAnthropicTextBlocks(choice.message.content)
     const toolUseBlocks = getAnthropicToolUseBlocks(choice.message.tool_calls)
 
+    allThinkingBlocks.push(...thinkingBlocks)
     allTextBlocks.push(...textBlocks)
     allToolUseBlocks.push(...toolUseBlocks)
 
@@ -333,14 +338,13 @@ export function translateToAnthropic(
     }
   }
 
-  // Note: GitHub Copilot doesn't generate thinking blocks, so we don't include them in responses
-
+  // Order: thinking blocks first, then text blocks, then tool use blocks
   return {
     id: response.id,
     type: "message",
     role: "assistant",
     model: response.model,
-    content: [...allTextBlocks, ...allToolUseBlocks],
+    content: [...allThinkingBlocks, ...allTextBlocks, ...allToolUseBlocks],
     stop_reason: mapOpenAIStopReasonToAnthropic(stopReason),
     stop_sequence: null,
     usage: {
@@ -357,6 +361,23 @@ export function translateToAnthropic(
   }
 }
 
+// PR #167: Extract thinking blocks from reasoning fields (@caozhiyuan)
+function getAnthropicThinkingBlocks(
+  message: ResponseMessage,
+): Array<AnthropicThinkingBlock> {
+  const blocks: Array<AnthropicThinkingBlock> = []
+
+  // reasoning_text contains the actual thinking content
+  if (message.reasoning_text) {
+    blocks.push({
+      type: "thinking",
+      thinking: message.reasoning_text,
+    })
+  }
+
+  return blocks
+}
+
 function getAnthropicTextBlocks(
   messageContent: Message["content"],
 ): Array<AnthropicTextBlock> {