openclaw-autoproxy 1.0.2 → 1.0.5

package/dist/gateway/config.js

@@ -12,6 +12,16 @@ function parseCsvList(value) {
         .map((item) => item.trim())
         .filter(Boolean);
 }
+function parsePositiveInteger(value, fallback) {
+    if (!value) {
+        return fallback;
+    }
+    const parsed = Number.parseInt(value, 10);
+    if (!Number.isInteger(parsed) || parsed <= 0) {
+        return fallback;
+    }
+    return parsed;
+}
 function parseRetryCodes(value) {
     const defaults = new Set([412, 429, 500, 502, 503, 504]);
     if (!value) {
@@ -248,6 +258,9 @@ function loadRouteFileConfig() {
 const host = process.env.HOST ?? "0.0.0.0";
 const port = Number.parseInt(process.env.PORT ?? "8787", 10);
 const timeoutMs = Number.parseInt(process.env.REQUEST_TIMEOUT_MS ?? "60000", 10);
+const upstreamMaxConnections = parsePositiveInteger(process.env.UPSTREAM_MAX_CONNECTIONS, 200);
+const upstreamKeepAliveTimeoutMs = parsePositiveInteger(process.env.UPSTREAM_KEEPALIVE_TIMEOUT_MS, 60_000);
+const upstreamKeepAliveMaxTimeoutMs = parsePositiveInteger(process.env.UPSTREAM_KEEPALIVE_MAX_TIMEOUT_MS, 300_000);
 const upstreamBaseUrl = (process.env.UPSTREAM_BASE_URL ?? "https://api.openai.com").replace(/\/+$/, "");
 const routeFileConfig = loadRouteFileConfig();
 if (!Number.isInteger(port) || port < 1 || port > 65535) {
@@ -262,6 +275,9 @@ export const config = {
     timeoutMs,
     upstreamBaseUrl,
     upstreamApiKey: process.env.UPSTREAM_API_KEY ?? "",
+    upstreamMaxConnections,
+    upstreamKeepAliveTimeoutMs,
+    upstreamKeepAliveMaxTimeoutMs,
     retryStatusCodes: routeFileConfig.retryStatusCodes ?? parseRetryCodes(process.env.RETRY_STATUS_CODES),
     globalFallbackModels: parseCsvList(process.env.GLOBAL_FALLBACK_MODELS),
     modelFallbackMap: parseModelFallbackMap(process.env.MODEL_FALLBACK_MAP),

package/dist/gateway/model-load-metrics.js

@@ -0,0 +1,114 @@
+const DEFAULT_WINDOW_MS = 12 * 60 * 60 * 1000;
+const DEFAULT_MAX_SAMPLES_PER_MODEL = 5000;
+const modelSamples = new Map();
+function quantileFromSorted(values, q) {
+    if (values.length === 0) {
+        return 0;
+    }
+    const clampedQ = Math.max(0, Math.min(1, q));
+    const index = Math.floor((values.length - 1) * clampedQ);
+    return values[index] ?? values[values.length - 1] ?? 0;
+}
+function roundMs(value) {
+    return Math.round(value * 100) / 100;
+}
+function pruneModelSamples(samples, cutoffAt) {
+    let startIndex = 0;
+    while (startIndex < samples.length && samples[startIndex] && samples[startIndex].at < cutoffAt) {
+        startIndex += 1;
+    }
+    if (startIndex <= 0) {
+        return samples;
+    }
+    return samples.slice(startIndex);
+}
+function pruneExpiredSamples(cutoffAt) {
+    for (const [model, samples] of modelSamples.entries()) {
+        const pruned = pruneModelSamples(samples, cutoffAt);
+        if (pruned.length === 0) {
+            modelSamples.delete(model);
+            continue;
+        }
+        if (pruned !== samples) {
+            modelSamples.set(model, pruned);
+        }
+    }
+}
+export function recordModelLoadSample(model, loadMs) {
+    if (!model) {
+        return;
+    }
+    if (!Number.isFinite(loadMs) || loadMs <= 0) {
+        return;
+    }
+    const now = Date.now();
+    const sample = {
+        at: now,
+        loadMs,
+    };
+    const existing = modelSamples.get(model) ?? [];
+    existing.push(sample);
+    if (existing.length > DEFAULT_MAX_SAMPLES_PER_MODEL) {
+        existing.splice(0, existing.length - DEFAULT_MAX_SAMPLES_PER_MODEL);
+    }
+    modelSamples.set(model, existing);
+    const cutoffAt = now - DEFAULT_WINDOW_MS;
+    pruneExpiredSamples(cutoffAt);
+}
+function summarizeModel(model, samples) {
+    if (samples.length === 0) {
+        return null;
+    }
+    const loadValues = samples.map((sample) => sample.loadMs).sort((a, b) => a - b);
+    const total = loadValues.reduce((acc, value) => acc + value, 0);
+    const avgLoadMs = total / loadValues.length;
+    const minLoadMs = loadValues[0] ?? 0;
+    const maxLoadMs = loadValues[loadValues.length - 1] ?? 0;
+    const latestAt = samples[samples.length - 1]?.at ?? Date.now();
+    return {
+        model,
+        sampleCount: samples.length,
+        avgLoadMs: roundMs(avgLoadMs),
+        p50LoadMs: roundMs(quantileFromSorted(loadValues, 0.5)),
+        p95LoadMs: roundMs(quantileFromSorted(loadValues, 0.95)),
+        minLoadMs: roundMs(minLoadMs),
+        maxLoadMs: roundMs(maxLoadMs),
+        lastSeenAt: new Date(latestAt).toISOString(),
+    };
+}
+export function getModelLoadRankingHealth(windowMs = DEFAULT_WINDOW_MS) {
+    const normalizedWindowMs = Number.isFinite(windowMs) && windowMs > 0 ? windowMs : DEFAULT_WINDOW_MS;
+    const now = Date.now();
+    const cutoffAt = now - normalizedWindowMs;
+    pruneExpiredSamples(cutoffAt);
+    const summaries = [];
+    for (const [model, samples] of modelSamples.entries()) {
+        const filtered = pruneModelSamples(samples, cutoffAt);
+        if (filtered.length === 0) {
+            continue;
+        }
+        if (filtered !== samples) {
+            modelSamples.set(model, filtered);
+        }
+        const summary = summarizeModel(model, filtered);
+        if (summary) {
+            summaries.push(summary);
+        }
+    }
+    summaries.sort((a, b) => {
+        if (a.avgLoadMs !== b.avgLoadMs) {
+            return a.avgLoadMs - b.avgLoadMs;
+        }
+        if (a.p95LoadMs !== b.p95LoadMs) {
+            return a.p95LoadMs - b.p95LoadMs;
+        }
+        return b.sampleCount - a.sampleCount;
+    });
+    return {
+        windowHours: roundMs(normalizedWindowMs / (60 * 60 * 1000)),
+        rankedModels: summaries.map((entry, index) => ({
+            rank: index + 1,
+            ...entry,
+        })),
+    };
+}

package/dist/gateway/proxy.js

@@ -1,5 +1,8 @@
 import { PassThrough, Readable } from "node:stream";
+import { Agent } from "undici";
+import { createAnthropicMessagesEventStreamTransformer, maybeTransformAnthropicMessagesRequest, transformOpenAiChatCompletionToAnthropicMessage, transformUpstreamErrorToAnthropicError, } from "./anthropic-compat.js";
 import { config } from "./config.js";
+import { recordModelLoadSample } from "./model-load-metrics.js";
 const HOP_BY_HOP_HEADERS = new Set([
     "connection",
     "keep-alive",
@@ -13,8 +16,37 @@ const HOP_BY_HOP_HEADERS = new Set([
 const MAX_REQUEST_BODY_BYTES = 50 * 1024 * 1024;
 const AUTO_MODEL = "auto";
 let autoModelCursor = 0;
+const upstreamAgent = new Agent({
+    connections: config.upstreamMaxConnections,
+    pipelining: 1,
+    keepAliveTimeout: config.upstreamKeepAliveTimeoutMs,
+    keepAliveMaxTimeout: config.upstreamKeepAliveMaxTimeoutMs,
+});
+const fetchWithDispatcher = fetch;
+function formatGatewayLogValue(value) {
+    if (value === null || value === undefined || value === "") {
+        return "-";
+    }
+    const normalized = String(value);
+    return /\s|"/.test(normalized) ? JSON.stringify(normalized) : normalized;
+}
+function buildGatewayLogLine(protocol, event, fields) {
+    const parts = [
+        "[gateway]",
+        `protocol=${formatGatewayLogValue(protocol)}`,
+        `event=${formatGatewayLogValue(event)}`,
+    ];
+    for (const [key, value] of Object.entries(fields)) {
+        parts.push(`${key}=${formatGatewayLogValue(value)}`);
+    }
+    return parts.join(" ");
+}
 function logProxyModelRoute(params) {
-    console.log(`[gateway] requested_model=${params.requestedModel ?? "-"} used_model=${params.usedModel ?? "-"} route=${params.routeName ?? "-"}`);
+    console.log(buildGatewayLogLine(params.protocol, "routed", {
+        requested_model: params.requestedModel,
+        used_model: params.usedModel,
+        route: params.routeName,
+    }));
 }
 function resolveRouteNameForModel(modelId) {
     if (modelId && config.modelRouteMap[modelId]) {
@@ -23,7 +55,27 @@ function resolveRouteNameForModel(modelId) {
     return config.modelRouteMap["*"]?.routeName ?? null;
 }
 function logProxyModelSwitch(params) {
-    console.log(`[gateway] switch trigger_status=${params.triggerStatus} from_model=${params.fromModel ?? "-"} from_route=${params.fromRoute ?? "-"} to_model=${params.toModel ?? "-"} to_route=${params.toRoute ?? "-"}`);
+    console.log(buildGatewayLogLine(params.protocol, "switch", {
+        trigger_status: params.triggerStatus,
+        from_model: params.fromModel,
+        from_route: params.fromRoute,
+        to_model: params.toModel,
+        to_route: params.toRoute,
+    }));
+}
+function resolveGatewayProtocolFromPath(requestPath) {
+    const { pathname } = parsePathnameAndSearch(requestPath);
+    if (pathname === "/anthropic" ||
+        pathname.startsWith("/anthropic/") ||
+        isAnthropicApiPath(pathname)) {
+        return "anthropic";
+    }
+    return "openai";
+}
+function resolveGatewayProtocol(request) {
+    const rawUrl = request.url ?? "/";
+    const normalizedRawUrl = rawUrl.startsWith("/") ? rawUrl : `/${rawUrl}`;
+    return resolveGatewayProtocolFromPath(normalizedRawUrl);
 }
 function sendJson(response, statusCode, payload) {
     if (response.writableEnded) {
@@ -39,11 +91,25 @@ function normalizeRequestPath(request) {
     const rawUrl = request.url ?? "/";
     try {
         const parsed = new URL(rawUrl, "http://localhost");
-        return `${parsed.pathname}${parsed.search}`;
+        return normalizeGatewayRequestPath(`${parsed.pathname}${parsed.search}`);
     }
     catch {
-        return rawUrl.startsWith("/") ? rawUrl : `/${rawUrl}`;
+        const normalizedRawUrl = rawUrl.startsWith("/") ? rawUrl : `/${rawUrl}`;
+        return normalizeGatewayRequestPath(normalizedRawUrl);
+    }
+}
+function normalizeGatewayRequestPath(requestPath) {
+    const { pathname, search } = parsePathnameAndSearch(requestPath);
+    if (pathname === "/anthropic") {
+        return `/v1${search}`;
     }
+    if (pathname === "/anthropic/v1" || pathname.startsWith("/anthropic/v1/")) {
+        return `${pathname.slice("/anthropic".length)}${search}`;
+    }
+    if (pathname.startsWith("/anthropic/")) {
+        return `/v1${pathname.slice("/anthropic".length)}${search}`;
+    }
+    return `${pathname}${search}`;
 }
 function rotateCandidates(candidates, startIndex) {
     if (candidates.length <= 1) {
@@ -71,31 +137,102 @@ function buildModelCandidates(requestedModel) {
     // Non-auto requests are pinned to the exact model specified by client.
     return [requestedModel];
 }
-function buildRoutedUpstreamUrl(request, selectedRoute) {
+function parsePathnameAndSearch(requestPath) {
+    try {
+        const parsed = new URL(requestPath, "http://localhost");
+        return {
+            pathname: parsed.pathname,
+            search: parsed.search,
+        };
+    }
+    catch {
+        const [pathnamePart, ...searchParts] = requestPath.split("?");
+        return {
+            pathname: pathnamePart || "/",
+            search: searchParts.length > 0 ? `?${searchParts.join("?")}` : "",
+        };
+    }
+}
+function isAnthropicApiPath(pathname) {
+    return (pathname === "/v1/messages" ||
+        pathname.startsWith("/v1/messages/") ||
+        pathname === "/v1/models" ||
+        pathname === "/v1/complete");
+}
+function rewriteFixedChatCompletionsRouteUrlForAnthropic(routeUrl, requestPath) {
+    const { pathname: requestPathname, search: requestSearch } = parsePathnameAndSearch(requestPath);
+    if (!isAnthropicApiPath(requestPathname)) {
+        return null;
+    }
+    let parsedRouteUrl;
+    try {
+        parsedRouteUrl = new URL(routeUrl);
+    }
+    catch {
+        return null;
+    }
+    const normalizedRoutePath = parsedRouteUrl.pathname.replace(/\/+$/, "");
+    const fixedChatCompletionsSuffix = "/v1/chat/completions";
+    if (!normalizedRoutePath.endsWith(fixedChatCompletionsSuffix)) {
+        return null;
+    }
+    const routePrefixPath = normalizedRoutePath.slice(0, -fixedChatCompletionsSuffix.length);
+    parsedRouteUrl.pathname = `${routePrefixPath}${requestPathname}`.replace(/\/{2,}/g, "/");
+    parsedRouteUrl.search = requestSearch;
+    return parsedRouteUrl.toString();
+}
+function buildRoutedUpstreamUrl(requestPath, selectedRoute) {
     if (!selectedRoute) {
-        return `${config.upstreamBaseUrl}${normalizeRequestPath(request)}`;
+        return `${config.upstreamBaseUrl}${requestPath}`;
     }
     if (!selectedRoute.isBaseUrl) {
+        // Backward-compatible Anthropic support when route URL is fixed to /v1/chat/completions.
+        const anthropicCompatUrl = rewriteFixedChatCompletionsRouteUrlForAnthropic(selectedRoute.url, requestPath);
+        if (anthropicCompatUrl) {
+            return anthropicCompatUrl;
+        }
         return selectedRoute.url;
     }
     const routeBase = selectedRoute.url.replace(/\/+$/, "");
-    const requestPath = normalizeRequestPath(request);
     if (routeBase.endsWith("/v1") && requestPath.startsWith("/v1")) {
         return `${routeBase}${requestPath.slice(3)}`;
     }
     return `${routeBase}${requestPath}`;
 }
-function resolveUpstreamTarget(request, modelId) {
+function resolveUpstreamTarget(requestPath, modelId) {
     const modelRoute = modelId ? config.modelRouteMap[modelId] ?? null : null;
     const wildcardRoute = config.modelRouteMap["*"] ?? null;
     const selectedRoute = modelRoute ?? wildcardRoute;
     return {
-        upstreamUrl: buildRoutedUpstreamUrl(request, selectedRoute),
+        upstreamUrl: buildRoutedUpstreamUrl(requestPath, selectedRoute),
         selectedRoute,
     };
 }
+async function logUpstreamErrorResponse(params) {
+    let detail = "-";
+    try {
+        const raw = await params.response.clone().text();
+        const normalized = raw.replace(/\s+/g, " ").trim();
+        if (normalized) {
+            detail = normalized.slice(0, 2000);
+        }
+    }
+    catch {
+        detail = "<unavailable>";
+    }
+    console.error(buildGatewayLogLine(params.protocol, "upstream_error", {
+        status: params.response.status,
+        path: params.requestPath,
+        route: params.routeName,
+        model: params.modelId,
+        upstream: params.upstreamUrl,
+        detail,
+    }));
+}
 function buildUpstreamHeaders(reqHeaders, bodyLength, selectedRoute) {
     const headers = new Headers();
+    const selectedAuthHeader = selectedRoute?.authHeader || "authorization";
+    const conflictingAuthHeaders = ["authorization", "x-api-key", "api-key"];
     for (const [key, value] of Object.entries(reqHeaders)) {
         if (value === undefined) {
             continue;
@@ -106,13 +243,20 @@ function buildUpstreamHeaders(reqHeaders, bodyLength, selectedRoute) {
         }
         headers.set(key, Array.isArray(value) ? value.join(",") : String(value));
     }
+    if (selectedRoute?.apiKey) {
+        for (const headerName of conflictingAuthHeaders) {
+            if (headerName !== selectedAuthHeader) {
+                headers.delete(headerName);
+            }
+        }
+    }
     if (selectedRoute?.headers) {
         for (const [key, value] of Object.entries(selectedRoute.headers)) {
             headers.set(key, value);
         }
     }
     if (selectedRoute?.apiKey) {
-        const authHeader = selectedRoute.authHeader || "authorization";
+        const authHeader = selectedAuthHeader;
         const authPrefix = selectedRoute.authPrefix ?? "Bearer ";
         if (!headers.has(authHeader)) {
             headers.set(authHeader, `${authPrefix}${selectedRoute.apiKey}`);
@@ -224,12 +368,63 @@ async function fetchWithTimeout(url, options, timeoutMs) {
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
     try {
-        return await fetch(url, { ...options, signal: controller.signal });
+        return await fetchWithDispatcher(url, {
+            ...options,
+            signal: controller.signal,
+            dispatcher: upstreamAgent,
+        });
     }
     finally {
         clearTimeout(timeoutId);
     }
 }
+function createClientAbortSignal(request, response) {
+    const controller = new AbortController();
+    let aborted = false;
+    const abort = () => {
+        if (aborted) {
+            return;
+        }
+        aborted = true;
+        controller.abort();
+    };
+    request.once("aborted", abort);
+    response.once("close", () => {
+        if (!response.writableEnded) {
+            abort();
+        }
+    });
+    return controller.signal;
+}
+async function fetchWithTimeoutAndClientSignal(url, options, timeoutMs, clientSignal) {
+    if (!clientSignal) {
+        return fetchWithTimeout(url, options, timeoutMs);
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+    const onClientAbort = () => {
+        if (!controller.signal.aborted) {
+            controller.abort();
+        }
+    };
+    if (clientSignal.aborted) {
+        onClientAbort();
+    }
+    else {
+        clientSignal.addEventListener("abort", onClientAbort, { once: true });
+    }
+    try {
+        return await fetchWithDispatcher(url, {
+            ...options,
+            signal: controller.signal,
+            dispatcher: upstreamAgent,
+        });
+    }
+    finally {
+        clearTimeout(timeoutId);
+        clientSignal.removeEventListener("abort", onClientAbort);
+    }
+}
 async function disposeBody(response) {
     if (!response.body) {
         return;
@@ -295,6 +490,9 @@ async function readRequestBody(request) {
 export async function proxyRequest(request, response) {
     const method = (request.method ?? "GET").toUpperCase();
     const supportsBody = method !== "GET" && method !== "HEAD";
+    const clientSignal = createClientAbortSignal(request, response);
+    const normalizedRequestPath = normalizeRequestPath(request);
+    const requestProtocol = resolveGatewayProtocol(request);
     let incomingBody = Buffer.alloc(0);
     if (supportsBody) {
         try {
@@ -344,23 +542,62 @@ export async function proxyRequest(request, response) {
     let switchNotice = null;
     for (let attemptIndex = 0; attemptIndex < modelCandidates.length; attemptIndex += 1) {
         const modelId = modelCandidates[attemptIndex];
-        let bodyBuffer = supportsBody && incomingBody.length > 0 ? incomingBody : undefined;
-        if (supportsBody && parsedJsonBody && modelId) {
-            bodyBuffer = Buffer.from(JSON.stringify({
+        let requestPath = normalizedRequestPath;
+        let responseFormat = null;
+        let requestJsonPayload = null;
+        if (supportsBody && parsedJsonBody) {
+            requestJsonPayload = {
                 ...parsedJsonBody,
-                model: modelId,
-            }), "utf8");
+                ...(modelId ? { model: modelId } : {}),
+            };
         }
-        const { upstreamUrl, selectedRoute } = resolveUpstreamTarget(request, modelId);
+        let { upstreamUrl, selectedRoute } = resolveUpstreamTarget(requestPath, modelId);
         lastAttemptRouteName = selectedRoute?.routeName ?? null;
+        if (requestJsonPayload) {
+            const compatRequest = maybeTransformAnthropicMessagesRequest({
+                requestPath,
+                upstreamUrl,
+                body: requestJsonPayload,
+            });
+            if (compatRequest.error) {
+                console.error(buildGatewayLogLine(requestProtocol, "compat_error", {
+                    path: requestPath,
+                    route: selectedRoute?.routeName ?? null,
+                    model: modelId,
+                    detail: compatRequest.error,
+                }));
+                sendJson(response, 400, {
+                    error: {
+                        message: compatRequest.error,
+                    },
+                });
+                return;
+            }
+            requestPath = compatRequest.requestPath;
+            requestJsonPayload = compatRequest.body;
+            responseFormat = compatRequest.responseFormat;
+            if (responseFormat) {
+                upstreamUrl = buildRoutedUpstreamUrl(requestPath, selectedRoute);
+            }
+        }
+        let bodyBuffer = supportsBody && incomingBody.length > 0 ? incomingBody : undefined;
+        if (supportsBody && requestJsonPayload) {
+            bodyBuffer = Buffer.from(JSON.stringify(requestJsonPayload), "utf8");
+        }
         const requestBody = bodyBuffer ? new Uint8Array(bodyBuffer) : undefined;
         const headers = buildUpstreamHeaders(request.headers, bodyBuffer ? bodyBuffer.length : undefined, selectedRoute);
         try {
-            const upstreamResponse = await fetchWithTimeout(upstreamUrl, {
+            const attemptStartedAt = Date.now();
+            const upstreamResponse = await fetchWithTimeoutAndClientSignal(upstreamUrl, {
                 method,
                 headers,
                 body: requestBody,
-            }, config.timeoutMs);
+            }, config.timeoutMs, clientSignal);
+            const headerLoadMs = Date.now() - attemptStartedAt;
+            const modelForMetric = modelId ?? requestedModel;
+            if (upstreamResponse.ok) {
+                recordModelLoadSample(modelForMetric, headerLoadMs);
+            }
             const contentType = (upstreamResponse.headers.get("content-type") ?? "").toLowerCase();
             const isEventStream = contentType.includes("text/event-stream");
             const isJsonResponse = contentType.includes("application/json");
@@ -378,6 +615,7 @@ export async function proxyRequest(request, response) {
                 const triggerStatus = retryTriggerStatus ?? upstreamResponse.status;
                 const nextRouteName = resolveRouteNameForModel(nextModel);
                 logProxyModelSwitch({
+                    protocol: requestProtocol,
                     triggerStatus,
                     fromModel: modelId,
                     toModel: nextModel,
@@ -396,6 +634,16 @@ export async function proxyRequest(request, response) {
                 await disposeBody(upstreamResponse);
                 continue;
             }
+            if (!upstreamResponse.ok) {
+                await logUpstreamErrorResponse({
+                    protocol: requestProtocol,
+                    requestPath,
+                    upstreamUrl,
+                    routeName: selectedRoute?.routeName ?? null,
+                    modelId,
+                    response: upstreamResponse,
+                });
+            }
             const attemptCount = attemptIndex + 1;
             const effectiveSwitchNotice = switchNotice;
             copyResponseHeaders(upstreamResponse, response);
@@ -407,6 +655,7 @@ export async function proxyRequest(request, response) {
                 response.setHeader("x-gateway-switched", "1");
             }
             logProxyModelRoute({
+                protocol: requestProtocol,
                 requestedModel,
                 usedModel: modelId,
                 routeName: selectedRoute?.routeName ?? null,
@@ -416,6 +665,61 @@ export async function proxyRequest(request, response) {
                 response.end();
                 return;
             }
+            if (responseFormat === "anthropic-messages" && isEventStream) {
+                const nodeStream = Readable.fromWeb(upstreamResponse.body);
+                const anthropicStream = nodeStream.pipe(createAnthropicMessagesEventStreamTransformer(modelId));
+                response.removeHeader("content-length");
+                response.setHeader("content-type", "text/event-stream; charset=utf-8");
+                if (effectiveSwitchNotice) {
+                    createSsePrefixedStream(anthropicStream, effectiveSwitchNotice).pipe(response);
+                    return;
+                }
+                anthropicStream.on("error", () => {
+                    if (!response.writableEnded) {
+                        response.destroy();
+                    }
+                });
+                anthropicStream.pipe(response);
+                return;
+            }
+            if (responseFormat === "anthropic-messages" && isJsonResponse && !isEventStream) {
+                const rawText = await upstreamResponse.text();
+                response.removeHeader("content-length");
+                response.setHeader("content-type", "application/json; charset=utf-8");
+                try {
+                    const parsed = JSON.parse(rawText);
+                    if (!upstreamResponse.ok) {
+                        response.end(JSON.stringify(transformUpstreamErrorToAnthropicError(parsed, upstreamResponse.status)));
+                        return;
+                    }
+                    const transformed = transformOpenAiChatCompletionToAnthropicMessage(parsed, modelId);
+                    if (transformed.value) {
+                        response.end(JSON.stringify(transformed.value));
+                        return;
+                    }
+                    console.error(buildGatewayLogLine(requestProtocol, "compat_error", {
+                        path: requestPath,
+                        route: selectedRoute?.routeName ?? null,
+                        model: modelId,
+                        detail: transformed.error ?? "Unknown transform error",
+                    }));
+                    sendJson(response, 502, {
+                        error: {
+                            message: "Gateway failed to translate the OpenAI-compatible response to Anthropic format.",
+                            detail: transformed.error ?? "Unknown transform error",
+                        },
+                    });
+                    return;
+                }
+                catch {
+                    if (!upstreamResponse.ok) {
+                        response.end(JSON.stringify(transformUpstreamErrorToAnthropicError({
+                            message: rawText,
+                        }, upstreamResponse.status)));
+                        return;
+                    }
+                }
+            }
             if (effectiveSwitchNotice && isJsonResponse && !isEventStream) {
                 const rawText = await upstreamResponse.text();
                 response.removeHeader("content-length");
@@ -461,6 +765,7 @@ export async function proxyRequest(request, response) {
     const errorStatusCode = timeoutLike ? 504 : 502;
     const lastTriedModel = modelCandidates[modelCandidates.length - 1] ?? null;
     logProxyModelRoute({
+        protocol: requestProtocol,
         requestedModel,
         usedModel: lastTriedModel,
         routeName: lastAttemptRouteName,

package/dist/gateway/server-http.js

@@ -1,5 +1,6 @@
 import { createServer } from "node:http";
 import { config } from "./config.js";
+import { getModelLoadRankingHealth } from "./model-load-metrics.js";
 import { proxyRequest } from "./proxy.js";
 function sendJson(response, statusCode, payload) {
     if (response.writableEnded) {
@@ -20,24 +21,33 @@ function resolvePathname(request) {
         return rawUrl.startsWith("/") ? rawUrl : `/${rawUrl}`;
     }
 }
+function isGatewayApiPath(pathname) {
+    return (pathname === "/v1" ||
+        pathname.startsWith("/v1/") ||
+        pathname === "/anthropic" ||
+        pathname.startsWith("/anthropic/"));
+}
 async function handleRequest(request, response) {
     const method = (request.method ?? "GET").toUpperCase();
     const pathname = resolvePathname(request);
     if ((method === "GET" || method === "HEAD") && pathname === "/health") {
+        const modelLoadHealth = getModelLoadRankingHealth(12 * 60 * 60 * 1000);
         sendJson(response, 200, {
             status: "ok",
             retryStatusCodes: Array.from(config.retryStatusCodes),
             enabledRouteCount: Object.keys(config.modelRouteMap).length,
+            modelLoadWindowHours: modelLoadHealth.windowHours,
+            modelLoadRanking: modelLoadHealth.rankedModels,
         });
         return;
     }
-    if (pathname === "/v1" || pathname.startsWith("/v1/")) {
+    if (isGatewayApiPath(pathname)) {
         await proxyRequest(request, response);
         return;
     }
     sendJson(response, 404, {
         error: {
-            message: "Route not found. Use /v1/* or /health.",
+            message: "Route not found. Use /v1/*, /anthropic/*, or /health.",
         },
     });
 }

package/dist/gateway/server.impl.js

@@ -21,7 +21,7 @@ export async function startGatewayServer(port = config.port, opts = {}) {
     });
     const address = server.address();
     const resolvedPort = typeof address === "object" && address ? address.port : port;
-    console.log(`Gateway listening on http://${host}:${resolvedPort} -> ${config.upstreamBaseUrl}`);
+    console.log(`Gateway listening on http://${host}:${resolvedPort}`);
     return {
         close: async () => {
             await new Promise((resolve, reject) => {