openclaw-autoproxy 1.0.1 → 1.0.2

package/bin/openclaw-autoproxy.js

@@ -12,7 +12,8 @@ const args = process.argv.slice(2);
 
 const currentFilePath = fileURLToPath(import.meta.url);
 const packageRoot = path.resolve(path.dirname(currentFilePath), "..");
-const serverEntryPath = path.join(packageRoot, "src", "gateway", "server.ts");
+const serverSourceEntryPath = path.join(packageRoot, "src", "gateway", "server.ts");
+const serverBuildEntryPath = path.join(packageRoot, "dist", "gateway", "server.js");
 const packageJsonPath = path.join(packageRoot, "package.json");
 const require = createRequire(import.meta.url);
 
@@ -79,7 +80,7 @@ function runTsxMode(tsxArgs) {
 
   if (!tsxCliPath || !existsSync(tsxCliPath)) {
     console.error(
-      "Missing tsx runtime. Reinstall package or install tsx globally (npm i -g tsx) and try again.",
+      "Missing tsx runtime. Install tsx globally (npm i -g tsx) or run a build that generates dist files.",
     );
     process.exit(1);
   }
@@ -100,12 +101,34 @@ function runTsxMode(tsxArgs) {
   });
 }
 
+function runNodeMode(nodeArgs) {
+  const child = spawn(process.execPath, nodeArgs, {
+    stdio: "inherit",
+    cwd: process.cwd(),
+    env: process.env,
+  });
+
+  child.on("exit", (code, signal) => {
+    if (signal) {
+      process.kill(process.pid, signal);
+      return;
+    }
+
+    process.exit(code ?? 0);
+  });
+}
+
 function runDevMode(extraArgs) {
-  runTsxMode(["watch", serverEntryPath, ...extraArgs]);
+  runTsxMode(["watch", serverSourceEntryPath, ...extraArgs]);
 }
 
 function runStartMode(extraArgs) {
-  runTsxMode([serverEntryPath, ...extraArgs]);
+  if (existsSync(serverBuildEntryPath)) {
+    runNodeMode([serverBuildEntryPath, ...extraArgs]);
+    return;
+  }
+
+  runTsxMode([serverSourceEntryPath, ...extraArgs]);
 }
 
 function isHelpFlag(value) {

package/dist/gateway/config.js

@@ -0,0 +1,269 @@
+import fs from "node:fs";
+import path from "node:path";
+import dotenv from "dotenv";
+import { parse as parseYaml } from "yaml";
+dotenv.config();
+function parseCsvList(value) {
+    if (!value) {
+        return [];
+    }
+    return value
+        .split(",")
+        .map((item) => item.trim())
+        .filter(Boolean);
+}
+function parseRetryCodes(value) {
+    const defaults = new Set([412, 429, 500, 502, 503, 504]);
+    if (!value) {
+        return defaults;
+    }
+    const parsed = value
+        .split(",")
+        .map((item) => Number.parseInt(item.trim(), 10))
+        .filter((code) => Number.isInteger(code) && code >= 100 && code <= 9999);
+    return parsed.length > 0 ? new Set(parsed) : defaults;
+}
+function parseRetryCodesFromConfig(value) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (!Array.isArray(value)) {
+        throw new Error('"retryStatusCodes" must be an array.');
+    }
+    const parsed = value
+        .map((item) => {
+        if (typeof item === "number") {
+            return item;
+        }
+        if (typeof item === "string") {
+            return Number.parseInt(item.trim(), 10);
+        }
+        return Number.NaN;
+    })
+        .filter((code) => Number.isInteger(code) && code >= 100 && code <= 9999);
+    if (parsed.length === 0) {
+        throw new Error('"retryStatusCodes" must include at least one valid status code (100-9999).');
+    }
+    return new Set(parsed);
+}
+function parseModelFallbackMap(value) {
+    if (!value) {
+        return {};
+    }
+    try {
+        const parsed = JSON.parse(value);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+            throw new Error("MODEL_FALLBACK_MAP must be a JSON object.");
+        }
+        return Object.fromEntries(Object.entries(parsed).map(([model, fallbacks]) => {
+            if (!Array.isArray(fallbacks)) {
+                throw new Error(`Fallback list for "${model}" must be an array.`);
+            }
+            return [
+                model,
+                fallbacks.map((item) => String(item).trim()).filter(Boolean),
+            ];
+        }));
+    }
+    catch (error) {
+        throw new Error(`Invalid MODEL_FALLBACK_MAP: ${error.message}`);
+    }
+}
+function parseRouteHeaders(value, routeName) {
+    if (value === undefined) {
+        return {};
+    }
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error(`Route headers for "${routeName}" must be a YAML object.`);
+    }
+    return Object.fromEntries(Object.entries(value).map(([rawKey, rawValue]) => {
+        const key = String(rawKey).trim();
+        const val = String(rawValue).trim();
+        if (!key) {
+            throw new Error(`Route headers for "${routeName}" contains an empty key.`);
+        }
+        return [key, val];
+    }));
+}
+function parseModelList(value, routeName) {
+    if (typeof value === "string") {
+        const normalized = value.trim();
+        return normalized ? [normalized] : [];
+    }
+    if (!Array.isArray(value)) {
+        throw new Error(`Route "${routeName}" must include "model" as string or array.`);
+    }
+    return value.map((item) => String(item).trim()).filter(Boolean);
+}
+function resolveRouteApiKey(rawRoute, defaults) {
+    const apiKeyInline = typeof rawRoute.apiKey === "string" ? rawRoute.apiKey.trim() : "";
+    if (apiKeyInline) {
+        return apiKeyInline;
+    }
+    const apiKeyEnv = typeof rawRoute.apiKeyEnv === "string" ? rawRoute.apiKeyEnv.trim() : "";
+    if (apiKeyEnv) {
+        return process.env[apiKeyEnv] ?? "";
+    }
+    if (defaults.apiKey) {
+        return defaults.apiKey;
+    }
+    return defaults.apiKeyEnv ? process.env[defaults.apiKeyEnv] ?? "" : "";
+}
+function normalizeGlobalRouteDefaults(value) {
+    if (value === undefined || value === null) {
+        return {};
+    }
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error("Route defaults must be an object.");
+    }
+    const defaults = value;
+    return {
+        authHeader: typeof defaults.authHeader === "string" && defaults.authHeader.trim()
+            ? defaults.authHeader.trim().toLowerCase()
+            : undefined,
+        authPrefix: typeof defaults.authPrefix === "string" ? defaults.authPrefix : undefined,
+        apiKey: typeof defaults.apiKey === "string" ? defaults.apiKey.trim() : undefined,
+        apiKeyEnv: typeof defaults.apiKeyEnv === "string" && defaults.apiKeyEnv.trim()
+            ? defaults.apiKeyEnv.trim()
+            : undefined,
+        headers: parseRouteHeaders(defaults.headers, "defaults"),
+        isBaseUrl: typeof defaults.isBaseUrl === "boolean" ? defaults.isBaseUrl : undefined,
+        enabled: typeof defaults.enabled === "boolean" ? defaults.enabled : undefined,
+    };
+}
+function normalizeRouteConfig(rawRoute, routeName, defaults) {
+    if (!rawRoute || typeof rawRoute !== "object" || Array.isArray(rawRoute)) {
+        throw new Error(`Route "${routeName}" must be an object.`);
+    }
+    const url = typeof rawRoute.url === "string" ? rawRoute.url.trim() : "";
+    if (!url) {
+        throw new Error(`Route "${routeName}" must include a non-empty "url".`);
+    }
+    const models = parseModelList(rawRoute.model ?? rawRoute.models, routeName);
+    if (models.length === 0) {
+        throw new Error(`Route "${routeName}" must include at least one model.`);
+    }
+    const authHeader = typeof rawRoute.authHeader === "string" && rawRoute.authHeader.trim()
+        ? rawRoute.authHeader.trim().toLowerCase()
+        : defaults.authHeader ?? "authorization";
+    const authPrefix = typeof rawRoute.authPrefix === "string" ? rawRoute.authPrefix : defaults.authPrefix ?? "Bearer ";
+    const isBaseUrl = typeof rawRoute.isBaseUrl === "boolean"
+        ? rawRoute.isBaseUrl
+        : Boolean(defaults.isBaseUrl);
+    const enabled = typeof rawRoute.enabled === "boolean" ? rawRoute.enabled : defaults.enabled ?? true;
+    const headers = {
+        ...(defaults.headers ?? {}),
+        ...parseRouteHeaders(rawRoute.headers, routeName),
+    };
+    return {
+        routeName,
+        url,
+        authHeader,
+        authPrefix,
+        apiKey: resolveRouteApiKey(rawRoute, defaults),
+        headers,
+        isBaseUrl,
+        enabled,
+        models,
+    };
+}
+function parseRouteArray(value, defaults) {
+    if (!Array.isArray(value)) {
+        throw new Error('Route config must include "routes" as an array.');
+    }
+    return value.map((entry, index) => {
+        if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+            throw new Error(`Route entry at index ${index} must be an object.`);
+        }
+        const routeData = entry;
+        const name = typeof routeData.name === "string" ? routeData.name.trim() : "";
+        const routeName = name || `routes[${index}]`;
+        return normalizeRouteConfig(routeData, routeName, defaults);
+    });
+}
+function parseModelRouteConfigFile(filePathRaw) {
+    const filePath = String(filePathRaw).trim();
+    if (!filePath) {
+        throw new Error("Route config path cannot be empty.");
+    }
+    const resolvedPath = path.isAbsolute(filePath) ? filePath : path.resolve(process.cwd(), filePath);
+    let raw = "";
+    try {
+        raw = fs.readFileSync(resolvedPath, "utf8");
+    }
+    catch (error) {
+        throw new Error(`Failed to read route config file "${resolvedPath}": ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+    let parsed;
+    try {
+        parsed = parseYaml(raw);
+    }
+    catch (error) {
+        throw new Error(`Invalid route config YAML at "${resolvedPath}": ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+    let defaults = {};
+    let routeEntries;
+    let retryStatusCodesFromFile;
+    if (Array.isArray(parsed)) {
+        routeEntries = parsed;
+    }
+    else if (parsed && typeof parsed === "object") {
+        const objectParsed = parsed;
+        retryStatusCodesFromFile = parseRetryCodesFromConfig(objectParsed.retryStatusCodes);
+        defaults = normalizeGlobalRouteDefaults(objectParsed.defaults ?? objectParsed.global ?? objectParsed.auth);
+        routeEntries = objectParsed.routes;
+    }
+    else {
+        throw new Error(`Route config file "${resolvedPath}" must be a YAML object or array.`);
+    }
+    const parsedRoutes = parseRouteArray(routeEntries, defaults);
+    const modelRouteMap = {};
+    for (const route of parsedRoutes) {
+        if (!route.enabled) {
+            continue;
+        }
+        const { routeName, models, enabled: _enabled, ...routeConfig } = route;
+        for (const modelId of models) {
+            if (modelRouteMap[modelId]) {
+                throw new Error(`Duplicate model "${modelId}" found in enabled routes (route "${routeName}").`);
+            }
+            modelRouteMap[modelId] = {
+                ...routeConfig,
+                routeName,
+            };
+        }
+    }
+    return {
+        modelRouteMap,
+        retryStatusCodes: retryStatusCodesFromFile,
+    };
+}
+function loadRouteFileConfig() {
+    const defaultRouteConfigPath = path.resolve(process.cwd(), "routes.yml");
+    if (!fs.existsSync(defaultRouteConfigPath)) {
+        throw new Error(`Missing routes config file at "${defaultRouteConfigPath}". Create routes.yml in project root.`);
+    }
+    return parseModelRouteConfigFile(defaultRouteConfigPath);
+}
+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 upstreamBaseUrl = (process.env.UPSTREAM_BASE_URL ?? "https://api.openai.com").replace(/\/+$/, "");
+const routeFileConfig = loadRouteFileConfig();
+if (!Number.isInteger(port) || port < 1 || port > 65535) {
+    throw new Error("PORT must be a valid TCP port number.");
+}
+if (!Number.isInteger(timeoutMs) || timeoutMs < 1000) {
+    throw new Error("REQUEST_TIMEOUT_MS must be an integer >= 1000.");
+}
+export const config = {
+    host,
+    port,
+    timeoutMs,
+    upstreamBaseUrl,
+    upstreamApiKey: process.env.UPSTREAM_API_KEY ?? "",
+    retryStatusCodes: routeFileConfig.retryStatusCodes ?? parseRetryCodes(process.env.RETRY_STATUS_CODES),
+    globalFallbackModels: parseCsvList(process.env.GLOBAL_FALLBACK_MODELS),
+    modelFallbackMap: parseModelFallbackMap(process.env.MODEL_FALLBACK_MAP),
+    modelRouteMap: routeFileConfig.modelRouteMap,
+};

package/dist/gateway/proxy.js

@@ -0,0 +1,474 @@
+import { PassThrough, Readable } from "node:stream";
+import { config } from "./config.js";
+const HOP_BY_HOP_HEADERS = new Set([
+    "connection",
+    "keep-alive",
+    "proxy-authenticate",
+    "proxy-authorization",
+    "te",
+    "trailer",
+    "transfer-encoding",
+    "upgrade",
+]);
+const MAX_REQUEST_BODY_BYTES = 50 * 1024 * 1024;
+const AUTO_MODEL = "auto";
+let autoModelCursor = 0;
+function logProxyModelRoute(params) {
+    console.log(`[gateway] requested_model=${params.requestedModel ?? "-"} used_model=${params.usedModel ?? "-"} route=${params.routeName ?? "-"}`);
+}
+function resolveRouteNameForModel(modelId) {
+    if (modelId && config.modelRouteMap[modelId]) {
+        return config.modelRouteMap[modelId].routeName;
+    }
+    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 ?? "-"}`);
+}
+function sendJson(response, statusCode, payload) {
+    if (response.writableEnded) {
+        return;
+    }
+    const body = JSON.stringify(payload);
+    response.statusCode = statusCode;
+    response.setHeader("content-type", "application/json; charset=utf-8");
+    response.setHeader("content-length", Buffer.byteLength(body));
+    response.end(body);
+}
+function normalizeRequestPath(request) {
+    const rawUrl = request.url ?? "/";
+    try {
+        const parsed = new URL(rawUrl, "http://localhost");
+        return `${parsed.pathname}${parsed.search}`;
+    }
+    catch {
+        return rawUrl.startsWith("/") ? rawUrl : `/${rawUrl}`;
+    }
+}
+function rotateCandidates(candidates, startIndex) {
+    if (candidates.length <= 1) {
+        return [...candidates];
+    }
+    const normalizedStart = startIndex % candidates.length;
+    return [
+        ...candidates.slice(normalizedStart),
+        ...candidates.slice(0, normalizedStart),
+    ];
+}
+function buildAutoModelCandidates() {
+    const routableModels = Object.keys(config.modelRouteMap).filter((modelName) => modelName !== "*" && modelName.toLowerCase() !== AUTO_MODEL);
+    if (routableModels.length === 0) {
+        return [];
+    }
+    const rotated = rotateCandidates(routableModels, autoModelCursor);
+    autoModelCursor = (autoModelCursor + 1) % routableModels.length;
+    return rotated;
+}
+function buildModelCandidates(requestedModel) {
+    if (requestedModel.toLowerCase() === AUTO_MODEL) {
+        return buildAutoModelCandidates();
+    }
+    // Non-auto requests are pinned to the exact model specified by client.
+    return [requestedModel];
+}
+function buildRoutedUpstreamUrl(request, selectedRoute) {
+    if (!selectedRoute) {
+        return `${config.upstreamBaseUrl}${normalizeRequestPath(request)}`;
+    }
+    if (!selectedRoute.isBaseUrl) {
+        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) {
+    const modelRoute = modelId ? config.modelRouteMap[modelId] ?? null : null;
+    const wildcardRoute = config.modelRouteMap["*"] ?? null;
+    const selectedRoute = modelRoute ?? wildcardRoute;
+    return {
+        upstreamUrl: buildRoutedUpstreamUrl(request, selectedRoute),
+        selectedRoute,
+    };
+}
+function buildUpstreamHeaders(reqHeaders, bodyLength, selectedRoute) {
+    const headers = new Headers();
+    for (const [key, value] of Object.entries(reqHeaders)) {
+        if (value === undefined) {
+            continue;
+        }
+        const lowerKey = key.toLowerCase();
+        if (HOP_BY_HOP_HEADERS.has(lowerKey) || lowerKey === "host" || lowerKey === "content-length") {
+            continue;
+        }
+        headers.set(key, Array.isArray(value) ? value.join(",") : String(value));
+    }
+    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 authPrefix = selectedRoute.authPrefix ?? "Bearer ";
+        if (!headers.has(authHeader)) {
+            headers.set(authHeader, `${authPrefix}${selectedRoute.apiKey}`);
+        }
+    }
+    else if (!headers.has("authorization") && config.upstreamApiKey) {
+        headers.set("authorization", `Bearer ${config.upstreamApiKey}`);
+    }
+    if (typeof bodyLength === "number") {
+        headers.set("content-length", String(bodyLength));
+    }
+    return headers;
+}
+function isJsonRequest(headers) {
+    const contentTypeHeader = headers["content-type"];
+    const contentType = Array.isArray(contentTypeHeader)
+        ? contentTypeHeader.join(";").toLowerCase()
+        : String(contentTypeHeader ?? "").toLowerCase();
+    return contentType.includes("application/json");
+}
+function parseJsonBody(buffer, shouldParse) {
+    if (!shouldParse || buffer.length === 0) {
+        return { parsed: null, error: null };
+    }
+    try {
+        const parsed = JSON.parse(buffer.toString("utf8"));
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            return { parsed: parsed, error: null };
+        }
+        return { parsed: null, error: null };
+    }
+    catch {
+        return { parsed: null, error: "Invalid JSON body." };
+    }
+}
+function parseStatusLikeCode(value) {
+    if (typeof value === "number" && Number.isInteger(value)) {
+        return value >= 100 && value <= 9999 ? value : null;
+    }
+    if (typeof value === "string") {
+        const trimmed = value.trim();
+        if (!trimmed) {
+            return null;
+        }
+        const parsed = Number.parseInt(trimmed, 10);
+        return Number.isInteger(parsed) && parsed >= 100 && parsed <= 9999 ? parsed : null;
+    }
+    return null;
+}
+function extractRetryStatusFromJsonPayload(payload) {
+    if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+        return null;
+    }
+    const record = payload;
+    const candidates = [record.status, record.code, record.errorCode];
+    const nestedError = record.error;
+    if (nestedError && typeof nestedError === "object" && !Array.isArray(nestedError)) {
+        const nested = nestedError;
+        candidates.push(nested.status, nested.code, nested.errorCode);
+    }
+    const nestedErrors = record.errors;
+    if (Array.isArray(nestedErrors)) {
+        for (const item of nestedErrors) {
+            if (!item || typeof item !== "object" || Array.isArray(item)) {
+                continue;
+            }
+            const nested = item;
+            candidates.push(nested.status, nested.code, nested.errorCode);
+        }
+    }
+    for (const candidate of candidates) {
+        const parsed = parseStatusLikeCode(candidate);
+        if (parsed !== null) {
+            return parsed;
+        }
+    }
+    return null;
+}
+async function detectRetryStatusFromBody(upstreamResponse, retryStatusCodes) {
+    const contentType = (upstreamResponse.headers.get("content-type") ?? "").toLowerCase();
+    if (!contentType.includes("application/json") || contentType.includes("text/event-stream")) {
+        return null;
+    }
+    try {
+        const raw = await upstreamResponse.clone().text();
+        if (!raw.trim()) {
+            return null;
+        }
+        const parsed = JSON.parse(raw);
+        const statusFromPayload = extractRetryStatusFromJsonPayload(parsed);
+        if (statusFromPayload !== null && retryStatusCodes.has(statusFromPayload)) {
+            return statusFromPayload;
+        }
+    }
+    catch {
+        // Ignore probe errors and continue with normal response handling.
+    }
+    return null;
+}
+function copyResponseHeaders(upstreamResponse, response) {
+    for (const [key, value] of upstreamResponse.headers.entries()) {
+        if (HOP_BY_HOP_HEADERS.has(key.toLowerCase())) {
+            continue;
+        }
+        response.setHeader(key, value);
+    }
+}
+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 });
+    }
+    finally {
+        clearTimeout(timeoutId);
+    }
+}
+async function disposeBody(response) {
+    if (!response.body) {
+        return;
+    }
+    try {
+        await response.body.cancel();
+    }
+    catch {
+        // Body cancellation is best effort.
+    }
+}
+function createSsePrefixedStream(source, notice) {
+    const passthrough = new PassThrough();
+    passthrough.write(`event: gateway_notice\ndata: ${JSON.stringify(notice)}\n\n`);
+    source.on("error", () => {
+        passthrough.end();
+    });
+    source.pipe(passthrough);
+    return passthrough;
+}
+async function readRequestBody(request) {
+    return await new Promise((resolve, reject) => {
+        const chunks = [];
+        let totalSize = 0;
+        let settled = false;
+        request.on("data", (chunk) => {
+            if (settled) {
+                return;
+            }
+            const normalizedChunk = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+            totalSize += normalizedChunk.length;
+            if (totalSize > MAX_REQUEST_BODY_BYTES) {
+                settled = true;
+                request.destroy();
+                reject(new Error(`Request body exceeds ${MAX_REQUEST_BODY_BYTES} bytes.`));
+                return;
+            }
+            chunks.push(normalizedChunk);
+        });
+        request.on("end", () => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            resolve(Buffer.concat(chunks));
+        });
+        request.on("aborted", () => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            reject(new Error("Request was aborted by client."));
+        });
+        request.on("error", (error) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            reject(error);
+        });
+    });
+}
+export async function proxyRequest(request, response) {
+    const method = (request.method ?? "GET").toUpperCase();
+    const supportsBody = method !== "GET" && method !== "HEAD";
+    let incomingBody = Buffer.alloc(0);
+    if (supportsBody) {
+        try {
+            incomingBody = await readRequestBody(request);
+        }
+        catch (error) {
+            const isBodyTooLarge = error instanceof Error &&
+                error.message.includes("exceeds") &&
+                error.message.includes("bytes");
+            sendJson(response, isBodyTooLarge ? 413 : 400, {
+                error: {
+                    message: "Failed to read request body.",
+                    detail: error instanceof Error ? error.message : "Unknown error",
+                },
+            });
+            return;
+        }
+    }
+    const wantsJson = isJsonRequest(request.headers);
+    const { parsed: parsedJsonBody, error: parseError } = parseJsonBody(incomingBody, wantsJson);
+    if (parseError) {
+        sendJson(response, 400, {
+            error: {
+                message: parseError,
+            },
+        });
+        return;
+    }
+    const requestedModel = parsedJsonBody &&
+        typeof parsedJsonBody.model === "string" &&
+        parsedJsonBody.model.trim()
+        ? parsedJsonBody.model.trim()
+        : null;
+    const modelCandidates = requestedModel
+        ? buildModelCandidates(requestedModel)
+        : [null];
+    if (requestedModel?.toLowerCase() === AUTO_MODEL && modelCandidates.length === 0) {
+        sendJson(response, 400, {
+            error: {
+                message: 'No auto model candidates configured. Set routes, GLOBAL_FALLBACK_MODELS, or MODEL_FALLBACK_MAP["auto"].',
+            },
+        });
+        return;
+    }
+    let lastError = null;
+    let lastAttemptRouteName = null;
+    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({
+                ...parsedJsonBody,
+                model: modelId,
+            }), "utf8");
+        }
+        const { upstreamUrl, selectedRoute } = resolveUpstreamTarget(request, modelId);
+        lastAttemptRouteName = selectedRoute?.routeName ?? null;
+        const requestBody = bodyBuffer ? new Uint8Array(bodyBuffer) : undefined;
+        const headers = buildUpstreamHeaders(request.headers, bodyBuffer ? bodyBuffer.length : undefined, selectedRoute);
+        try {
+            const upstreamResponse = await fetchWithTimeout(upstreamUrl, {
+                method,
+                headers,
+                body: requestBody,
+            }, config.timeoutMs);
+            const contentType = (upstreamResponse.headers.get("content-type") ?? "").toLowerCase();
+            const isEventStream = contentType.includes("text/event-stream");
+            const isJsonResponse = contentType.includes("application/json");
+            const hasNextCandidate = attemptIndex < modelCandidates.length - 1;
+            const httpRetryStatus = config.retryStatusCodes.has(upstreamResponse.status)
+                ? upstreamResponse.status
+                : null;
+            const bodyRetryStatus = !httpRetryStatus && hasNextCandidate
+                ? await detectRetryStatusFromBody(upstreamResponse, config.retryStatusCodes)
+                : null;
+            const retryTriggerStatus = httpRetryStatus ?? bodyRetryStatus;
+            const canRetry = retryTriggerStatus !== null && hasNextCandidate;
+            if (canRetry) {
+                const nextModel = modelCandidates[attemptIndex + 1];
+                const triggerStatus = retryTriggerStatus ?? upstreamResponse.status;
+                const nextRouteName = resolveRouteNameForModel(nextModel);
+                logProxyModelSwitch({
+                    triggerStatus,
+                    fromModel: modelId,
+                    toModel: nextModel,
+                    fromRoute: selectedRoute?.routeName ?? null,
+                    toRoute: nextRouteName,
+                });
+                if (modelId && nextModel && nextModel !== modelId) {
+                    switchNotice = {
+                        trigger_status: triggerStatus,
+                        from_model: modelId,
+                        from_route: selectedRoute?.routeName ?? null,
+                        to_model: nextModel,
+                        to_route: nextRouteName,
+                    };
+                }
+                await disposeBody(upstreamResponse);
+                continue;
+            }
+            const attemptCount = attemptIndex + 1;
+            const effectiveSwitchNotice = switchNotice;
+            copyResponseHeaders(upstreamResponse, response);
+            response.setHeader("x-gateway-attempt-count", String(attemptCount));
+            if (modelId) {
+                response.setHeader("x-gateway-model-used", modelId);
+            }
+            if (effectiveSwitchNotice) {
+                response.setHeader("x-gateway-switched", "1");
+            }
+            logProxyModelRoute({
+                requestedModel,
+                usedModel: modelId,
+                routeName: selectedRoute?.routeName ?? null,
+            });
+            response.statusCode = upstreamResponse.status;
+            if (!upstreamResponse.body) {
+                response.end();
+                return;
+            }
+            if (effectiveSwitchNotice && isJsonResponse && !isEventStream) {
+                const rawText = await upstreamResponse.text();
+                response.removeHeader("content-length");
+                try {
+                    const parsed = JSON.parse(rawText);
+                    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+                        parsed.gateway_notice = effectiveSwitchNotice;
+                        response.end(JSON.stringify(parsed));
+                        return;
+                    }
+                }
+                catch {
+                    // Keep original response body when JSON mutation is not possible.
+                }
+                response.end(rawText);
+                return;
+            }
+            const nodeStream = Readable.fromWeb(upstreamResponse.body);
+            if (effectiveSwitchNotice && isEventStream) {
+                response.removeHeader("content-length");
+                createSsePrefixedStream(nodeStream, effectiveSwitchNotice).pipe(response);
+                return;
+            }
+            nodeStream.on("error", () => {
+                if (!response.writableEnded) {
+                    response.destroy();
+                }
+            });
+            nodeStream.pipe(response);
+            return;
+        }
+        catch (error) {
+            lastError = error;
+            if (attemptIndex < modelCandidates.length - 1) {
+                continue;
+            }
+        }
+    }
+    const timeoutLike = lastError &&
+        typeof lastError === "object" &&
+        "name" in lastError &&
+        lastError.name === "AbortError";
+    const errorStatusCode = timeoutLike ? 504 : 502;
+    const lastTriedModel = modelCandidates[modelCandidates.length - 1] ?? null;
+    logProxyModelRoute({
+        requestedModel,
+        usedModel: lastTriedModel,
+        routeName: lastAttemptRouteName,
+    });
+    sendJson(response, errorStatusCode, {
+        error: {
+            message: "Gateway failed to reach upstream provider.",
+            detail: lastError instanceof Error ? lastError.message : "Unknown error",
+        },
+    });
+}

package/dist/gateway/server-http.js

@@ -0,0 +1,55 @@
+import { createServer } from "node:http";
+import { config } from "./config.js";
+import { proxyRequest } from "./proxy.js";
+function sendJson(response, statusCode, payload) {
+    if (response.writableEnded) {
+        return;
+    }
+    const body = JSON.stringify(payload);
+    response.statusCode = statusCode;
+    response.setHeader("content-type", "application/json; charset=utf-8");
+    response.setHeader("content-length", Buffer.byteLength(body));
+    response.end(body);
+}
+function resolvePathname(request) {
+    const rawUrl = request.url ?? "/";
+    try {
+        return new URL(rawUrl, "http://localhost").pathname;
+    }
+    catch {
+        return rawUrl.startsWith("/") ? rawUrl : `/${rawUrl}`;
+    }
+}
+async function handleRequest(request, response) {
+    const method = (request.method ?? "GET").toUpperCase();
+    const pathname = resolvePathname(request);
+    if ((method === "GET" || method === "HEAD") && pathname === "/health") {
+        sendJson(response, 200, {
+            status: "ok",
+            retryStatusCodes: Array.from(config.retryStatusCodes),
+            enabledRouteCount: Object.keys(config.modelRouteMap).length,
+        });
+        return;
+    }
+    if (pathname === "/v1" || pathname.startsWith("/v1/")) {
+        await proxyRequest(request, response);
+        return;
+    }
+    sendJson(response, 404, {
+        error: {
+            message: "Route not found. Use /v1/* or /health.",
+        },
+    });
+}
+export function createGatewayHttpServer() {
+    return createServer((request, response) => {
+        void handleRequest(request, response).catch((error) => {
+            sendJson(response, 500, {
+                error: {
+                    message: "Unexpected gateway error.",
+                    detail: error instanceof Error ? error.message : "Unknown error",
+                },
+            });
+        });
+    });
+}

package/dist/gateway/server.impl.js

@@ -0,0 +1,38 @@
+import { config } from "./config.js";
+import { createGatewayHttpServer } from "./server-http.js";
+export async function startGatewayServer(port = config.port, opts = {}) {
+    const host = opts.host ?? config.host;
+    const server = createGatewayHttpServer();
+    await new Promise((resolve, reject) => {
+        const onError = (error) => {
+            server.off("listening", onListening);
+            reject(error);
+        };
+        const onListening = () => {
+            server.off("error", onError);
+            resolve();
+        };
+        server.once("error", onError);
+        server.once("listening", onListening);
+        server.listen({
+            host,
+            port,
+        });
+    });
+    const address = server.address();
+    const resolvedPort = typeof address === "object" && address ? address.port : port;
+    console.log(`Gateway listening on http://${host}:${resolvedPort} -> ${config.upstreamBaseUrl}`);
+    return {
+        close: async () => {
+            await new Promise((resolve, reject) => {
+                server.close((error) => {
+                    if (error) {
+                        reject(error);
+                        return;
+                    }
+                    resolve();
+                });
+            });
+        },
+    };
+}

package/dist/gateway/server.js

@@ -0,0 +1,27 @@
+import process from "node:process";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { config } from "./config.js";
+import { startGatewayServer as startGatewayServerImpl } from "./server.impl.js";
+export { startGatewayServer } from "./server.impl.js";
+async function main() {
+    try {
+        await startGatewayServerImpl(config.port, { host: config.host });
+    }
+    catch (error) {
+        console.error(error instanceof Error
+            ? `Failed to start gateway: ${error.message}`
+            : "Failed to start gateway due to an unknown error.");
+        process.exit(1);
+    }
+}
+const invokedAsScript = (() => {
+    const scriptArg = process.argv[1];
+    if (!scriptArg) {
+        return false;
+    }
+    return pathToFileURL(path.resolve(scriptArg)).href === import.meta.url;
+})();
+if (invokedAsScript) {
+    void main();
+}

package/package.json

@@ -1,14 +1,16 @@
 {
   "name": "openclaw-autoproxy",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "Local model-switching proxy gateway with OpenAI-compatible APIs",
   "type": "module",
-  "main": "src/gateway/server.ts",
+  "main": "dist/gateway/server.js",
   "bin": {
     "openclaw-autoproxy": "bin/openclaw-autoproxy.js"
   },
   "scripts": {
     "cli": "node bin/openclaw-autoproxy.js",
+    "build": "tsc -p tsconfig.build.json",
+    "prepack": "npm run build",
     "start": "node bin/openclaw-autoproxy.js gateway start",
     "dev": "node bin/openclaw-autoproxy.js gateway dev",
     "typecheck": "tsc --noEmit",

package/tsconfig.build.json

@@ -0,0 +1,12 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "noEmit": false,
+    "outDir": "dist",
+    "rootDir": "src",
+    "sourceMap": false,
+    "declaration": false
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "dist"]
+}