@jiayunxie/aerial 0.2.1 → 0.2.2

package/src/proxy/effort.js

@@ -0,0 +1,120 @@
+import { loadConfig } from "../shared/config.js";
+import { logEvent } from "../shared/log.js";
+import { canonicalClaudeFamily, findCompatibleModel as findCompatibleModelShared } from "./model-catalog.js";
+import { withDefaultAnthropicCache, withDefaultPromptCache } from "./cache-policy.js";
+
+function normalizeProxyEffort(effort) {
+  return effort === "max" ? "xhigh" : effort;
+}
+
+function openAIEffortRoute(model, effort) {
+  if (effort === undefined) return undefined;
+  const normalized = normalizeProxyEffort(effort);
+  if (/^gpt-5-mini(?:-|$)/.test(model) && normalized === "xhigh") return "high";
+  if (normalized !== effort) return normalized;
+  return undefined;
+}
+
+function withSupportedOpenAIEffort(payload) {
+  const model = typeof payload?.model === "string" ? payload.model : "";
+  const reasoningEffort = payload?.reasoning && typeof payload.reasoning === "object" ? payload.reasoning.effort : undefined;
+  const nextReasoningEffort = openAIEffortRoute(model, reasoningEffort);
+  const nextFlatEffort = openAIEffortRoute(model, payload?.reasoning_effort);
+  if (!nextReasoningEffort && !nextFlatEffort) return payload;
+
+  const next = { ...payload };
+  if (nextReasoningEffort) next.reasoning = { ...payload.reasoning, effort: nextReasoningEffort };
+  if (nextFlatEffort) next.reasoning_effort = nextFlatEffort;
+  logEvent("openai_effort_route", {
+    model,
+    effort: reasoningEffort ?? payload?.reasoning_effort,
+    routedEffort: nextReasoningEffort ?? nextFlatEffort
+  });
+  return next;
+}
+
+export function withOpenAIDefaults(payload) {
+  return withDefaultPromptCache(withSupportedOpenAIEffort(payload));
+}
+
+function objectOrEmpty(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+
+function withSupportedAnthropicEffort(payload, models) {
+  const effort = payload?.output_config?.effort;
+  if (effort === undefined) return payload;
+  const model = typeof payload?.model === "string" ? payload.model : "";
+  const family = canonicalClaudeFamily(model);
+  if (!family) return payload;
+  const nextEffort = normalizeProxyEffort(effort);
+  if (!["low", "medium", "high", "xhigh"].includes(nextEffort)) return payload;
+  const routed = findCompatibleModelShared({
+    models,
+    family,
+    route: "/v1/messages",
+    adaptiveThinking: true,
+    effort: nextEffort,
+    preferredId: model
+  });
+  const nextModel = routed?.id || model;
+  if (model === nextModel && effort === nextEffort) return payload;
+  logEvent("anthropic_effort_route", { model, effort, routedModel: nextModel, routedEffort: nextEffort });
+  return { ...payload, model: nextModel, output_config: { ...payload.output_config, effort: nextEffort } };
+}
+
+function legacyThinkingEffort(thinking) {
+  if (typeof thinking?.effort === "string" && thinking.effort.trim()) return thinking.effort.trim();
+  const budget = Number(thinking?.budget_tokens);
+  if (!Number.isFinite(budget) || budget <= 0) return "medium";
+  if (budget <= 4096) return "low";
+  if (budget <= 16000) return "medium";
+  if (budget <= 64000) return "high";
+  return "xhigh";
+}
+
+function isLegacyThinkingEnabled(thinking) {
+  if (!thinking || typeof thinking !== "object" || Array.isArray(thinking)) return false;
+  if (thinking.type === "enabled") return true;
+  return Boolean(thinking.type && typeof thinking.type === "object" && thinking.type.enabled);
+}
+
+function withSupportedAnthropicThinking(payload) {
+  if (!isLegacyThinkingEnabled(payload?.thinking)) return payload;
+  const outputConfig = objectOrEmpty(payload?.output_config);
+  const effort = outputConfig.effort ?? legacyThinkingEffort(payload.thinking);
+  logEvent("anthropic_thinking_route", { model: payload.model, routedType: "adaptive", routedEffort: effort });
+  return {
+    ...payload,
+    thinking: { type: "adaptive" },
+    output_config: { ...outputConfig, effort }
+  };
+}
+
+function shouldLoadAnthropicCatalog(payload) {
+  const effort = payload?.output_config?.effort;
+  const model = typeof payload?.model === "string" ? payload.model : "";
+  return effort !== undefined && Boolean(canonicalClaudeFamily(model));
+}
+
+function withDefaultAnthropicEffort(payload) {
+  if (payload?.output_config?.effort !== undefined) return payload;
+  if (payload?.thinking?.type === "adaptive") return payload;
+  const model = typeof payload?.model === "string" ? payload.model : "";
+  if (!canonicalClaudeFamily(model)) return payload;
+  const config = loadConfig();
+  const effort = config.defaultEffort || "medium";
+  const outputConfig = objectOrEmpty(payload?.output_config);
+  logEvent("anthropic_default_effort", { model, effort });
+  return { ...payload, output_config: { ...outputConfig, effort } };
+}
+
+export async function withAnthropicDefaults(payload, loadModels) {
+  const cached = withDefaultAnthropicCache(payload);
+  const thinkingApplied = withSupportedAnthropicThinking(cached);
+  const next = withDefaultAnthropicEffort(thinkingApplied);
+  const models = shouldLoadAnthropicCatalog(next)
+    ? await loadModels().catch(() => undefined)
+    : undefined;
+  return withSupportedAnthropicEffort(next, models);
+}

package/src/proxy/headers.js

@@ -0,0 +1,33 @@
+import crypto from "node:crypto";
+import { loadConfig } from "../shared/config.js";
+
+export function upstreamHeaders(token, extra = {}) {
+  const config = loadConfig();
+  const requestId = extra["x-request-id"] || crypto.randomUUID();
+  return {
+    authorization: `Bearer ${token}`,
+    accept: extra.accept || "application/json",
+    "content-type": extra["content-type"] || "application/json",
+    "copilot-integration-id": "vscode-chat",
+    "editor-device-id": config.deviceId || "aerial-local",
+    "editor-version": `vscode/${config.versions.vscode}`,
+    "editor-plugin-version": `copilot-chat/${config.versions.copilotChat}`,
+    "user-agent": `GitHubCopilotChat/${config.versions.copilotChat}`,
+    "openai-intent": "conversation-agent",
+    "x-github-api-version": "2026-01-09",
+    "x-request-id": requestId,
+    "x-agent-task-id": requestId,
+    "x-interaction-type": "conversation-agent",
+    "x-vscode-user-agent-library-version": "electron-fetch",
+    ...extra
+  };
+}
+
+export function copyResponseHeaders(upstream) {
+  const headers = new Headers();
+  const contentType = upstream.headers.get("content-type");
+  if (contentType) headers.set("content-type", contentType);
+  const cacheControl = upstream.headers.get("cache-control");
+  if (cacheControl) headers.set("cache-control", cacheControl);
+  return headers;
+}

package/src/proxy/index.js

@@ -0,0 +1,85 @@
+import { DEFAULT_ANTHROPIC_VERSION } from "../shared/constants.js";
+import { getCopilotToken } from "../shared/auth.js";
+import { logEvent } from "../shared/log.js";
+import { isResponsesWebSocketOptIn, proxyResponsesWebSocket, shouldUseResponsesWebSocket } from "./responses-websocket.js";
+import { annotateModelsResponse } from "./models.js";
+import { upstreamHeaders } from "./headers.js";
+import { withAnthropicDefaults, withOpenAIDefaults } from "./effort.js";
+import {
+  cacheRequestFields,
+  createSseCacheObserver,
+  hasExplicitCacheRequest,
+  responseHasVision,
+  responseInitiator
+} from "./cache-telemetry.js";
+import { fetchModelsCatalogForCopilot, proxyFetch, requestWithJsonBody } from "./transport.js";
+
+function responseModelFromCatalog(modelId, models) {
+  return models.find((model) => model.id === modelId);
+}
+
+export async function proxyModels(request) {
+  const upstreamRequest = new Request(request.url, { method: "GET", headers: request.headers });
+  return annotateModelsResponse(await proxyFetch("/models", upstreamRequest));
+}
+
+export async function proxyResponses(request) {
+  const payload = withOpenAIDefaults(await request.json());
+  const body = Buffer.from(JSON.stringify(payload));
+
+  if (payload?.stream && isResponsesWebSocketOptIn()) {
+    const models = await fetchModelsCatalogForCopilot().catch(() => undefined);
+    const model = models ? responseModelFromCatalog(payload.model, models) : undefined;
+    if (shouldUseResponsesWebSocket(payload, model)) {
+      const requestCache = cacheRequestFields(payload);
+      if (hasExplicitCacheRequest(requestCache)) logEvent("cache_request", { route: "/responses", ...requestCache });
+      const token = await getCopilotToken();
+      const initiator = responseInitiator(payload);
+      const headers = upstreamHeaders(token, {
+        accept: "text/event-stream",
+        "content-type": request.headers.get("content-type") || "application/json",
+        ...(responseHasVision(payload) ? { "copilot-vision-request": "true" } : {})
+      });
+      logEvent("responses_websocket", { model: payload.model });
+      const response = await proxyResponsesWebSocket(payload, headers, { initiator });
+      if (!response.body) return response;
+      const observer = createSseCacheObserver("/responses", requestCache);
+      return new Response(response.body.pipeThrough(observer), { status: response.status, headers: response.headers });
+    }
+    logEvent("responses_websocket_skip", {
+      model: payload.model,
+      reason: !model ? "model_unknown" : "model_no_ws_endpoint"
+    });
+  }
+
+  const upstreamRequest = new Request(request.url, { method: request.method, headers: request.headers, body, duplex: "half" });
+  return proxyFetch("/responses", upstreamRequest, { bodyOverride: body });
+}
+
+export async function proxyMessages(request) {
+  const extraHeaders = {
+    "anthropic-version": request.headers.get("anthropic-version") || DEFAULT_ANTHROPIC_VERSION
+  };
+  const beta = request.headers.get("anthropic-beta");
+  if (beta) extraHeaders["anthropic-beta"] = beta;
+  const upstreamRequest = await requestWithJsonBody(request, (payload) => withAnthropicDefaults(payload, fetchModelsCatalogForCopilot));
+  return proxyFetch("/v1/messages", upstreamRequest, { extraHeaders });
+}
+
+export async function proxyChatCompletions(request) {
+  const upstreamRequest = await requestWithJsonBody(request, (payload) => {
+    payload = withOpenAIDefaults(payload);
+    if (payload.max_tokens !== undefined && payload.max_completion_tokens === undefined) {
+      const { max_tokens, ...rest } = payload;
+      return { ...rest, max_completion_tokens: max_tokens };
+    }
+    return payload;
+  });
+  return proxyFetch("/chat/completions", upstreamRequest);
+}
+
+export async function localCountTokens(request) {
+  const payload = await request.json().catch(() => ({}));
+  const serialized = JSON.stringify(payload.messages || payload.input || payload);
+  return Response.json({ input_tokens: Math.ceil(serialized.length / 4) });
+}

package/src/proxy/models.js

@@ -0,0 +1,27 @@
+export function aerialSupportForModel(model) {
+  const endpoints = Array.isArray(model.supported_endpoints) ? model.supported_endpoints : [];
+  const routes = [];
+  const notes = [];
+  if (endpoints.includes("/responses")) routes.push("responses");
+  if (endpoints.includes("ws:/responses")) routes.push("responses_websocket");
+  if (endpoints.includes("/v1/messages")) routes.push("messages");
+  if (endpoints.includes("/chat/completions")) routes.push("chat");
+  if (model.capabilities?.type === "embeddings") notes.push("embeddings_not_implemented");
+  if (routes.length === 0 && notes.length === 0) notes.push("no_supported_endpoint_advertised");
+  return {
+    supported: routes.length > 0,
+    routes,
+    notes
+  };
+}
+
+export async function annotateModelsResponse(response) {
+  const contentType = response.headers.get("content-type") || "";
+  if (!response.ok || !contentType.includes("application/json")) return response;
+  const payload = await response.json();
+  if (!Array.isArray(payload.data)) return Response.json(payload, { status: response.status, headers: response.headers });
+  return Response.json({
+    ...payload,
+    data: payload.data.map((model) => ({ ...model, aerial: aerialSupportForModel(model) }))
+  }, { status: response.status });
+}

package/src/{responses-websocket.js → proxy/responses-websocket.js}

@@ -1,6 +1,6 @@
 import { WebSocket } from "undici";
-import { COPILOT_API_ORIGIN } from "./constants.js";
-import { upstreamDispatcher } from "./upstream-fetch.js";
+import { COPILOT_API_ORIGIN } from "../shared/constants.js";
+import { upstreamDispatcher } from "../upstream/fetch.js";
 
 const TERMINAL_RESPONSE_TYPES = new Set([
   "response.completed",

package/src/{server.js → proxy/server.js}

@@ -1,9 +1,9 @@
 import http from "node:http";
-import { DEFAULT_HOST, DEFAULT_PORT } from "./constants.js";
-import { loadConfig, validateLocalAuth } from "./config.js";
-import { proxyChatCompletions, proxyMessages, proxyModels, proxyResponses, localCountTokens } from "./copilot.js";
-import { readGitHubToken } from "./auth.js";
-import { logEvent } from "./log.js";
+import { DEFAULT_HOST, DEFAULT_PORT } from "../shared/constants.js";
+import { loadConfig, validateLocalAuth } from "../shared/config.js";
+import { proxyChatCompletions, proxyMessages, proxyModels, proxyResponses, localCountTokens } from "./index.js";
+import { readGitHubToken } from "../shared/auth.js";
+import { logEvent } from "../shared/log.js";
 
 const MAX_BODY_BYTES = 32 * 1024 * 1024;
 

package/src/proxy/transport.js

@@ -0,0 +1,55 @@
+import { COPILOT_API_ORIGIN } from "../shared/constants.js";
+import { getCopilotToken } from "../shared/auth.js";
+import { logEvent } from "../shared/log.js";
+import { upstreamFetch } from "../upstream/fetch.js";
+import { fetchModelsCatalog as fetchModelsCatalogShared, tokenFingerprintOf } from "./model-catalog.js";
+import { copyResponseHeaders, upstreamHeaders } from "./headers.js";
+import {
+  cacheRequestFields,
+  hasExplicitCacheRequest,
+  parseJsonBody,
+  wrapResponseWithCacheObserver
+} from "./cache-telemetry.js";
+
+export async function requestWithJsonBody(request, transform) {
+  const payload = await request.json();
+  const nextPayload = await transform(payload);
+  return new Request(request.url, {
+    method: request.method,
+    headers: request.headers,
+    body: JSON.stringify(nextPayload),
+    duplex: "half"
+  });
+}
+
+export async function proxyFetch(path, request, { extraHeaders = {}, bodyOverride } = {}) {
+  const token = await getCopilotToken();
+  const body = bodyOverride ?? (request.method === "GET" || request.method === "HEAD" ? undefined : await request.arrayBuffer());
+  const accept = request.headers.get("accept") || "application/json";
+  const contentType = request.headers.get("content-type") || "application/json";
+  const requestCache = cacheRequestFields(parseJsonBody(body, contentType));
+  if (hasExplicitCacheRequest(requestCache)) logEvent("cache_request", { route: path, ...requestCache });
+  const headers = upstreamHeaders(token, { accept, "content-type": contentType, ...extraHeaders });
+  let upstream = await upstreamFetch(`${COPILOT_API_ORIGIN}${path}`, { method: request.method, headers, body });
+  if (upstream.status === 401) {
+    const refreshed = await getCopilotToken({ force: true });
+    upstream = await upstreamFetch(`${COPILOT_API_ORIGIN}${path}`, { method: request.method, headers: upstreamHeaders(refreshed, { accept, "content-type": contentType, ...extraHeaders }), body });
+  }
+  if (path === "/models") {
+    return new Response(upstream.body, { status: upstream.status, headers: copyResponseHeaders(upstream) });
+  }
+  return wrapResponseWithCacheObserver(upstream, path, requestCache);
+}
+
+export async function fetchModelsCatalogForCopilot() {
+  const token = await getCopilotToken();
+  return fetchModelsCatalogShared({
+    tokenFingerprint: tokenFingerprintOf(token),
+    fetchImpl: async () => {
+      const response = await upstreamFetch(`${COPILOT_API_ORIGIN}/models`, { method: "GET", headers: upstreamHeaders(token) });
+      if (!response.ok) return undefined;
+      const payload = await response.json().catch(() => ({}));
+      return Array.isArray(payload?.data) ? payload.data : undefined;
+    }
+  });
+}

package/src/service/health.js

@@ -0,0 +1,54 @@
+const HEALTH_TIMEOUT_MS = 1500;
+const HEALTH_START_TIMEOUT_MS = 5000;
+const HEALTH_POLL_INTERVAL_MS = 250;
+
+export async function defaultHealthFetch(host, port) {
+  if (process.env.AERIAL_SERVICE_DRYRUN === "1") {
+    return { ok: false, error: "dryrun" };
+  }
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), HEALTH_TIMEOUT_MS);
+  try {
+    const res = await fetch(`http://${host}:${port}/health`, { signal: controller.signal });
+    let body;
+    let parseFailed = false;
+    try {
+      body = await res.json();
+    } catch {
+      parseFailed = true;
+    }
+    return { ok: res.ok, status: res.status, body, parseFailed };
+  } catch (err) {
+    return { ok: false, error: err.message };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+export function classifyHealth(probe) {
+  if (!probe || probe.error) return { mode: "absent" };
+  if (probe.status !== 200) return { mode: "absent", httpStatus: probe.status };
+  if (probe.parseFailed) return { mode: "port_conflict", reason: "health body is not JSON" };
+  if (!probe.body || probe.body.service !== "aerial") {
+    return { mode: "port_conflict", reason: "200 response but not Aerial" };
+  }
+  return { mode: "aerial_running", body: probe.body };
+}
+
+export async function pollForAerialUp(host, port, healthFetch, deadlineMs = HEALTH_START_TIMEOUT_MS) {
+  const fetcher = healthFetch || defaultHealthFetch;
+  const start = Date.now();
+  let lastProbe;
+  let lastCls;
+  let attempts = 0;
+  while (Date.now() - start < deadlineMs) {
+    attempts += 1;
+    lastProbe = await fetcher(host, port);
+    lastCls = classifyHealth(lastProbe);
+    if (lastCls.mode === "aerial_running" || lastCls.mode === "port_conflict") {
+      return { cls: lastCls, probe: lastProbe, attempts, elapsedMs: Date.now() - start };
+    }
+    await new Promise((r) => setTimeout(r, HEALTH_POLL_INTERVAL_MS));
+  }
+  return { cls: lastCls || { mode: "absent" }, probe: lastProbe, attempts, elapsedMs: Date.now() - start };
+}

package/src/service/index.js

@@ -0,0 +1,38 @@
+import {
+  SERVICE_LABEL,
+  WIN_TASK_NAME,
+  aerialLogPath,
+  buildSchtasksArgs,
+  darwinWrapperPath,
+  nodeBinary,
+  plistPath,
+  quoteSchtasksTR,
+  renderDarwinWrapper,
+  renderPlist,
+  renderWindowsWrapper,
+  stdioLogPath,
+  winWrapperPath
+} from "./wrapper-render.js";
+import { classifyHealth } from "./health.js";
+import { parseWrapperLogValues, parseWrapperPaths, wrapperBlock } from "./status.js";
+
+export { renderPlist, renderDarwinWrapper, renderWindowsWrapper, buildSchtasksCreateArgs } from "./wrapper-render.js";
+export { serviceInstall, serviceStart, serviceStop, serviceRestart, serviceUninstall } from "./lifecycle.js";
+export { serviceStatus } from "./status.js";
+
+export const _internal = {
+  SERVICE_LABEL,
+  WIN_TASK_NAME,
+  plistPath,
+  darwinWrapperPath,
+  winWrapperPath,
+  aerialLogPath,
+  stdioLogPath,
+  parseWrapperLogValues,
+  parseWrapperPaths,
+  wrapperBlock,
+  buildSchtasksArgs,
+  quoteSchtasksTR,
+  classifyHealth,
+  nodeBinary
+};