copilot-custom-endpoint 1.0.0 → 1.0.1

package/README.md

@@ -25,12 +25,11 @@ This repo is for those situations: validated, copy-paste-ready configs when Open
 | **Moonshot (Kimi)**           | `kimi-k2.6`    | Yes — `proxy/kimi-proxy.mjs`       | ✅         | ✅        | ✅           | ✅     |
 | **Alibaba Cloud (DashScope)** | `qwen3.6-plus` | Optional — `proxy/qwen-proxy.mjs`¹ | ✅²        | ✅        | ✅           | ✅     |
 | **Alibaba Cloud (DashScope)** | `qwen3.7-max`  | Optional — `proxy/qwen-proxy.mjs`¹ | ✅²        | ✅        | ✅           | ❌     |
-| **DeepSeek**                  | `deepseek-v4`  | No — uses a VS Code extension      | ✅         | ✅        | ✅           | ✅¹    |
+| **DeepSeek**                  | `deepseek-v4`  | No — uses a VS Code extension      | ✅         | ✅        | ✅           | ✅³    |
 
 ¹ Proxy is optional: direct path works with static `enable_thinking: false`. Proxy adds dynamic thinking suppression (thinking ON in plain chat, OFF in tool loops).  
-² With proxy: reasoning visible in plain chat. Without proxy: always suppressed.
-
-¹ Vision is supported through a proxy model (Claude, GPT-4o) that describes the image before sending to DeepSeek.
+² With proxy: reasoning visible in plain chat. Without proxy: always suppressed.  
+³ Vision is supported through a proxy model (Claude, GPT-4o) that describes the image before sending to DeepSeek.
 
 Pick the model you want and follow the corresponding section below.
 

package/lib/create-proxy.mjs

@@ -0,0 +1,186 @@
+import { createServer } from 'node:http'
+import { Readable } from 'node:stream'
+import {
+  appendLog,
+  buildForwardHeaders,
+  buildResponseHeaders,
+  readRequestBody,
+  redactHeaders
+} from './shared.mjs'
+
+/**
+ * Creates an HTTP proxy server (not yet listening) that forwards chat-completion
+ * requests to an upstream provider, applying provider-specific request rewrites.
+ *
+ * @param {object} options
+ * @param {string} options.upstreamUrl - Upstream chat-completions endpoint
+ * @param {number} options.port - Local listen port
+ * @param {string} options.logPath - Path to NDJSON log file
+ * @param {string} options.label - Short label for console messages (e.g. 'kimi-proxy')
+ * @param {object} options.healthCheckExtras - Extra fields to include in /healthz response
+ * @param {number} [options.fetchTimeoutMs=300_000] - Timeout for upstream fetch calls
+ * @param {function} options.rewriteRequest - (payload) => { summary: object, consoleMsg: string }
+ *   Called before forwarding. Should mutate `payload` in place. The returned `summary`
+ *   is merged into the NDJSON log entry. `consoleMsg` is printed to stdout.
+ * @param {function} options.startupMessages - (port, upstreamUrl) => string[] of startup log lines
+ * @returns {{ server: import('node:http').Server, start: () => void }}
+ */
+export function createProxy({
+  upstreamUrl,
+  port,
+  logPath,
+  label,
+  healthCheckExtras,
+  fetchTimeoutMs = 300_000,
+  rewriteRequest,
+  startupMessages
+}) {
+  if (!Number.isInteger(port) || port < 0) {
+    throw new Error(`Invalid port: ${port}`)
+  }
+
+  const server = createServer(async (request, response) => {
+    // ---- Health check ----
+    if (request.method === 'GET' && request.url === '/healthz') {
+      response.writeHead(200, { 'content-type': 'application/json' })
+      response.end(
+        JSON.stringify({
+          ok: true,
+          upstreamUrl,
+          port,
+          ...healthCheckExtras
+        })
+      )
+      return
+    }
+
+    // ---- Only POST ----
+    if (request.method !== 'POST') {
+      response.writeHead(404, { 'content-type': 'application/json' })
+      response.end(JSON.stringify({ error: 'Not found' }))
+      return
+    }
+
+    const startedAt = new Date().toISOString()
+    let requestBody
+
+    // ---- Read body ----
+    try {
+      requestBody = await readRequestBody(request)
+    } catch (error) {
+      response.writeHead(400, { 'content-type': 'application/json' })
+      response.end(JSON.stringify({ error: 'Unable to read request body' }))
+
+      await appendLog(
+        {
+          timestamp: startedAt,
+          type: 'read-error',
+          path: request.url,
+          error: error instanceof Error ? error.message : String(error)
+        },
+        logPath
+      )
+      return
+    }
+
+    // ---- Parse JSON ----
+    let payload
+
+    try {
+      payload = JSON.parse(requestBody)
+    } catch {
+      response.writeHead(400, { 'content-type': 'application/json' })
+      response.end(JSON.stringify({ error: 'Expected JSON request body' }))
+
+      await appendLog(
+        {
+          timestamp: startedAt,
+          type: 'invalid-json',
+          path: request.url,
+          headers: redactHeaders(request.headers)
+        },
+        logPath
+      )
+      return
+    }
+
+    // ---- Provider-specific rewrite ----
+    const { summary, consoleMsg } = rewriteRequest(payload)
+
+    // ---- Log request ----
+    await appendLog(
+      {
+        timestamp: startedAt,
+        type: 'request',
+        path: request.url,
+        headers: redactHeaders(request.headers),
+        summary
+      },
+      logPath
+    )
+
+    console.log(`[${label}] ${request.method} ${request.url} ${consoleMsg}`)
+
+    // ---- Forward to upstream ----
+    try {
+      const upstreamResponse = await fetch(upstreamUrl, {
+        method: 'POST',
+        headers: buildForwardHeaders(request.headers),
+        body: JSON.stringify(payload),
+        signal: AbortSignal.timeout(fetchTimeoutMs)
+      })
+
+      // ---- Log response ----
+      await appendLog(
+        {
+          timestamp: new Date().toISOString(),
+          type: 'response',
+          path: request.url,
+          status: upstreamResponse.status,
+          statusText: upstreamResponse.statusText,
+          contentType: upstreamResponse.headers.get('content-type'),
+          upstreamRequestId:
+            upstreamResponse.headers.get('x-request-id') ??
+            upstreamResponse.headers.get('request-id')
+        },
+        logPath
+      )
+
+      // ---- Forward response ----
+      response.writeHead(
+        upstreamResponse.status,
+        buildResponseHeaders(upstreamResponse.headers)
+      )
+
+      if (!upstreamResponse.body) {
+        response.end()
+        return
+      }
+
+      Readable.fromWeb(upstreamResponse.body).pipe(response)
+    } catch (error) {
+      response.writeHead(502, { 'content-type': 'application/json' })
+      response.end(JSON.stringify({ error: 'Upstream request failed' }))
+
+      await appendLog(
+        {
+          timestamp: new Date().toISOString(),
+          type: 'upstream-error',
+          path: request.url,
+          error: error instanceof Error ? error.message : String(error)
+        },
+        logPath
+      )
+    }
+  })
+
+  function start() {
+    server.listen(port, '127.0.0.1', () => {
+      for (const msg of startupMessages(port, upstreamUrl)) {
+        console.log(msg)
+      }
+    })
+  }
+
+  return { server, start }
+}

package/lib/shared.mjs

@@ -0,0 +1,125 @@
+import { appendFile, mkdir } from 'node:fs/promises'
+import { dirname } from 'node:path'
+
+// ---- Constants ----
+
+export const hopByHopHeaders = new Set([
+  'connection',
+  'keep-alive',
+  'proxy-authenticate',
+  'proxy-authorization',
+  'te',
+  'trailer',
+  'transfer-encoding',
+  'upgrade'
+])
+
+// ---- Header utilities ----
+
+/**
+ * Returns a shallow copy of `headers` with sensitive values redacted.
+ * `authorization` → `Bearer <redacted>`
+ * `x-api-key`     → `<redacted>`
+ * `undefined` values are dropped entirely.
+ */
+export function redactHeaders(headers) {
+  const redacted = {}
+
+  for (const [name, value] of Object.entries(headers)) {
+    if (value === undefined) {
+      continue
+    }
+
+    if (name.toLowerCase() === 'authorization') {
+      redacted[name] = 'Bearer <redacted>'
+      continue
+    }
+
+    if (name.toLowerCase() === 'x-api-key') {
+      redacted[name] = '<redacted>'
+      continue
+    }
+
+    redacted[name] = value
+  }
+
+  return redacted
+}
+
+/**
+ * Build a Headers object for the upstream request, filtering out
+ * hop-by-hop headers, `host`, and `content-length`, then forcing
+ * `content-type: application/json`.
+ */
+export function buildForwardHeaders(headers) {
+  const forwardHeaders = new Headers()
+
+  for (const [name, value] of Object.entries(headers)) {
+    const lowerName = name.toLowerCase()
+
+    if (
+      value === undefined ||
+      lowerName === 'host' ||
+      lowerName === 'content-length' ||
+      hopByHopHeaders.has(lowerName)
+    ) {
+      continue
+    }
+
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        forwardHeaders.append(name, item)
+      }
+      continue
+    }
+
+    forwardHeaders.set(name, value)
+  }
+
+  forwardHeaders.set('content-type', 'application/json')
+
+  return forwardHeaders
+}
+
+/**
+ * Build a plain object from a Headers instance, filtering out hop-by-hop headers.
+ */
+export function buildResponseHeaders(headers) {
+  const responseHeaders = {}
+
+  for (const [name, value] of headers.entries()) {
+    if (hopByHopHeaders.has(name.toLowerCase())) {
+      continue
+    }
+
+    responseHeaders[name] = value
+  }
+
+  return responseHeaders
+}
+
+// ---- Request body ----
+
+/**
+ * Read the full body from an async-iterable request-like object
+ * (e.g. `IncomingMessage` or a `Readable` stream) and return it as a UTF-8 string.
+ */
+export async function readRequestBody(request) {
+  const chunks = []
+
+  for await (const chunk of request) {
+    chunks.push(typeof chunk === 'string' ? Buffer.from(chunk) : chunk)
+  }
+
+  return Buffer.concat(chunks).toString('utf8')
+}
+
+// ---- Logging ----
+
+/**
+ * Append an NDJSON entry to `logPath`, creating parent directories as needed.
+ */
+export async function appendLog(entry, logPath) {
+  await mkdir(dirname(logPath), { recursive: true })
+  await appendFile(logPath, `${JSON.stringify(entry)}\n`, 'utf8')
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "copilot-custom-endpoint",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Local proxies for VS Code Copilot custom endpoints — Kimi K2 & Qwen 3.x",
   "license": "MIT",
   "type": "module",
@@ -11,6 +11,7 @@
   },
   "files": [
     "cli.mjs",
+    "lib/",
     "proxy/"
   ],
   "scripts": {