@nvae/llmswitch 0.6.0 → 0.8.0

package/dist/gateway/manager.js

@@ -0,0 +1,278 @@
+/**
+ * Gateway daemon lifecycle: probe, start, stop, foreground run.
+ *
+ * Mirrors the bridge manager's cooperative-shutdown model — the daemon is only
+ * ever asked to exit through an authenticated control call, never signalled by
+ * PID — but uses its own port, state file and log file.
+ */
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { existsSync, openSync, renameSync, rmSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { ensureDir } from "../utils/fs.js";
+import { getGatewayDir } from "../utils/paths.js";
+import { formatHostForUrl } from "../bridge/runtime.js";
+import { generateGatewayControlToken, gatewayRootUrl, readGatewayState, updateGatewayState, } from "./state.js";
+import { resolveGatewayListener } from "./runtime.js";
+import { listenGateway } from "./server.js";
+import { DEFAULT_GATEWAY_HOST, DEFAULT_GATEWAY_PORT, } from "./types.js";
+export class GatewayPortOccupiedError extends Error {
+    constructor(host, port) {
+        super(`端口 ${host}:${port} 已被其他进程占用；为避免误杀，llm-switch 不会自动终止该进程。`);
+        this.name = "GatewayPortOccupiedError";
+    }
+}
+export class GatewayControlError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "GatewayControlError";
+    }
+}
+export function getGatewayLogPath() {
+    return join(getGatewayDir(), "gateway.log");
+}
+const LOG_ROTATE_BYTES = 10 * 1024 * 1024;
+/** Size-based rotation at process start: gateway.log → gateway.log.old. */
+export function rotateGatewayLogIfNeeded() {
+    const path = getGatewayLogPath();
+    try {
+        if (statSync(path).size < LOG_ROTATE_BYTES)
+            return;
+        rmSync(`${path}.old`, { force: true });
+        renameSync(path, `${path}.old`);
+    }
+    catch {
+        // No log file yet, or rotation raced with another process; keep going.
+    }
+}
+function controlUrl(host, port, path) {
+    return `http://${formatHostForUrl(host)}:${port}${path}`;
+}
+export async function probeGateway(host = readGatewayState().listener.advertiseHost, port = readGatewayState().listener.port) {
+    const expected = readGatewayState().instance;
+    try {
+        const headers = {};
+        if (expected?.controlToken) {
+            headers["x-llm-switch-control"] = expected.controlToken;
+        }
+        const response = await fetch(controlUrl(host, port, "/health"), {
+            headers,
+            signal: AbortSignal.timeout(800),
+        });
+        let body = null;
+        try {
+            body = (await response.json());
+        }
+        catch {
+            body = null;
+        }
+        const instanceId = typeof body?.instanceId === "string" ? body.instanceId : undefined;
+        const breakers = Array.isArray(body?.breakers)
+            ? body.breakers
+            : undefined;
+        const stats = body?.stats;
+        return {
+            reachable: true,
+            healthy: Boolean(response.ok && expected && instanceId && instanceId === expected.id),
+            instanceId,
+            ...(typeof body?.startedAt === "string"
+                ? { startedAt: body.startedAt }
+                : {}),
+            ...(typeof body?.uptimeSeconds === "number"
+                ? { uptimeSeconds: body.uptimeSeconds }
+                : {}),
+            ...(stats && typeof stats === "object" ? { stats } : {}),
+            breakers,
+        };
+    }
+    catch {
+        return { reachable: false, healthy: false };
+    }
+}
+export async function isGatewayAlive(host = readGatewayState().listener.advertiseHost, port = readGatewayState().listener.port) {
+    return (await probeGateway(host, port)).healthy;
+}
+export function readGatewayPid() {
+    return readGatewayState().instance?.pid ?? null;
+}
+export function isPidRunning(pid) {
+    if (!Number.isInteger(pid) || pid < 1 || pid > 2_147_483_647)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Resolve how the detached daemon is launched. Node is preferred: Bun resolves
+ * target DNS locally, which defeats socks5h remote DNS for proxied upstreams.
+ */
+function resolveDaemonRunner() {
+    const candidates = [
+        fileURLToPath(new URL("../index.js", import.meta.url)),
+        fileURLToPath(new URL("../../dist/index.js", import.meta.url)),
+        fileURLToPath(new URL("../index.ts", import.meta.url)),
+    ];
+    for (const candidate of candidates) {
+        if (existsSync(candidate)) {
+            return candidate.endsWith(".js")
+                ? { command: "node", entry: candidate }
+                : { command: process.execPath, entry: candidate };
+        }
+    }
+    const running = process.argv[1];
+    if (running && existsSync(running)) {
+        return { command: process.execPath, entry: running };
+    }
+    throw new GatewayControlError("无法定位 llmswitch 入口文件");
+}
+export async function startGatewayDaemon(host = DEFAULT_GATEWAY_HOST, port = DEFAULT_GATEWAY_PORT, allowRemote = false) {
+    const listener = resolveGatewayListener({ host, port, allowRemote });
+    const probe = await probeGateway(listener.advertiseHost, listener.port);
+    if (probe.healthy)
+        return readGatewayPid() || 0;
+    if (probe.reachable) {
+        throw new GatewayPortOccupiedError(listener.bindHost, listener.port);
+    }
+    updateGatewayState((state) => ({ ...state, listener, instance: null }));
+    ensureDir(getGatewayDir());
+    rotateGatewayLogIfNeeded();
+    const logFd = openSync(getGatewayLogPath(), "a");
+    const runner = resolveDaemonRunner();
+    const args = [
+        runner.entry,
+        "gateway",
+        "serve",
+        "--host",
+        listener.bindHost,
+        "--port",
+        String(listener.port),
+    ];
+    if (allowRemote)
+        args.push("--allow-remote");
+    const child = spawn(runner.command, args, {
+        detached: true,
+        stdio: ["ignore", logFd, logFd],
+        env: {
+            ...process.env,
+            LLM_SWITCH_GATEWAY_HOST: listener.bindHost,
+            LLM_SWITCH_GATEWAY_PORT: String(listener.port),
+            LLM_SWITCH_GATEWAY_RUNTIME: runner.command,
+        },
+    });
+    child.unref();
+    if (!child.pid)
+        throw new GatewayControlError("无法启动 gateway 进程");
+    return child.pid;
+}
+export async function stopGateway() {
+    const state = readGatewayState();
+    const instance = state.instance;
+    if (!instance)
+        return false;
+    const probe = await probeGateway(state.listener.advertiseHost, state.listener.port);
+    if (!probe.reachable) {
+        // Stale identity: the process is gone, so clear it instead of erroring.
+        updateGatewayState((current) => current.instance?.id === instance.id
+            ? { ...current, instance: null }
+            : current);
+        return false;
+    }
+    if (!probe.healthy || probe.instanceId !== instance.id) {
+        throw new GatewayControlError("无法验证 gateway 实例身份；为避免误杀，未发送任何进程信号。");
+    }
+    let response;
+    try {
+        response = await fetch(controlUrl(state.listener.advertiseHost, state.listener.port, "/_control/shutdown"), {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                "x-llm-switch-control": instance.controlToken,
+            },
+            body: JSON.stringify({ instanceId: instance.id }),
+            signal: AbortSignal.timeout(2_000),
+        });
+    }
+    catch (error) {
+        throw new GatewayControlError(`Gateway 协作关闭失败：${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (!response.ok) {
+        throw new GatewayControlError(`Gateway 拒绝关闭请求（HTTP ${response.status}）`);
+    }
+    for (let attempt = 0; attempt < 100; attempt += 1) {
+        if (readGatewayState().instance?.id !== instance.id)
+            return true;
+        await new Promise((resolve) => setTimeout(resolve, 20));
+    }
+    throw new GatewayControlError("Gateway 已接受关闭请求，但未在宽限期内清除实例身份");
+}
+export async function runGatewayForeground(host, port, allowRemote = false) {
+    ensureDir(getGatewayDir());
+    rotateGatewayLogIfNeeded();
+    const listener = resolveGatewayListener({ host, port, allowRemote });
+    const previous = readGatewayState();
+    const instance = {
+        id: randomUUID(),
+        controlToken: generateGatewayControlToken(),
+        pid: process.pid,
+        startedAt: new Date().toISOString(),
+    };
+    updateGatewayState((state) => ({ ...state, listener, instance }));
+    let resolveClosed;
+    const closed = new Promise((resolve) => {
+        resolveClosed = resolve;
+    });
+    let server = null;
+    let closing = false;
+    const clearIdentity = () => {
+        updateGatewayState((state) => state.instance?.id === instance.id
+            ? { ...state, instance: null }
+            : state);
+    };
+    const shutdown = async (requestedId = instance.id) => {
+        if (requestedId !== instance.id || closing)
+            return;
+        closing = true;
+        if (server) {
+            const forceTimer = setTimeout(() => server?.closeAllConnections(), 30_000);
+            await new Promise((resolve) => server.close(() => resolve()));
+            clearTimeout(forceTimer);
+        }
+        clearIdentity();
+        resolveClosed?.();
+    };
+    try {
+        server = await listenGateway(listener.port, listener.bindHost, {
+            controlToken: instance.controlToken,
+            instanceId: instance.id,
+            onShutdown: shutdown,
+        });
+    }
+    catch (error) {
+        try {
+            clearIdentity();
+        }
+        catch {
+            // Preserve the original bind error.
+        }
+        if (error.code === "EADDRINUSE") {
+            throw new GatewayPortOccupiedError(listener.bindHost, listener.port);
+        }
+        updateGatewayState((state) => state.instance ? state : { ...state, listener: previous.listener });
+        throw error;
+    }
+    const onSignal = () => {
+        void shutdown();
+    };
+    process.once("SIGINT", onSignal);
+    process.once("SIGTERM", onSignal);
+    console.error(`llm-switch gateway listening on ${gatewayRootUrl(readGatewayState())}` +
+        `（bind ${formatHostForUrl(listener.bindHost)}:${listener.port}${listener.allowRemote ? "，已对外暴露" : ""}）`);
+    await closed;
+    process.removeListener("SIGINT", onSignal);
+    process.removeListener("SIGTERM", onSignal);
+}

package/dist/gateway/pipeline.js

@@ -0,0 +1,328 @@
+/**
+ * Format conversion pipeline.
+ *
+ * Every request is normalised into the hub format (OpenAI Chat Completions),
+ * then rendered into the upstream's format; responses travel back the same way.
+ * When the inbound and upstream formats match, callers should use raw
+ * passthrough instead to avoid a lossy round-trip.
+ */
+import { anthropicToChatRequest } from "./../bridge/anthropic-translate-request.js";
+import { chatChunkToAnthropicEvents, chatCompletionToAnthropicMessage, createAnthropicStreamState, forceCompleteAnthropicStream, } from "./../bridge/anthropic-translate-response.js";
+import { chatToAnthropicRequest } from "./../bridge/chat-to-anthropic-request.js";
+import { anthropicEventToChatChunks, anthropicMessageToChatCompletion, createAnthropicToChatStreamState, forceCompleteAnthropicToChatStream, parseAnthropicSseLine, } from "./../bridge/anthropic-to-chat-response.js";
+import { chatToResponsesRequest } from "./../bridge/chat-to-responses-request.js";
+import { collectCustomToolNames, responsesToChatRequest, } from "./../bridge/translate-request.js";
+import { chatChunkToResponsesEvents, chatCompletionToResponse, createStreamState, forceCompleteStream, parseChatSseLine, } from "./../bridge/translate-response.js";
+import { createResponsesToChatStreamState, forceCompleteResponsesToChatStream, parseResponsesSseLine, responseToChatCompletion, responsesEventToChatChunks, } from "./../bridge/responses-to-chat-response.js";
+export function parseInboundRequest(format, body) {
+    return {
+        format,
+        body,
+        requestedModel: String(body.model || ""),
+        stream: Boolean(body.stream),
+        customTools: format === "openai-responses"
+            ? collectCustomToolNames(body.tools)
+            : new Set(),
+    };
+}
+/** Inbound body → hub Chat Completions request. */
+export function inboundToChatRequest(inbound) {
+    switch (inbound.format) {
+        case "openai-chat":
+            return { ...inbound.body };
+        case "anthropic":
+            return anthropicToChatRequest(inbound.body);
+        case "openai-responses":
+            return responsesToChatRequest(inbound.body);
+    }
+}
+/** Upstream request path (relative to the provider base URL). */
+export function upstreamPath(format) {
+    switch (format) {
+        case "openai-chat":
+            return "/chat/completions";
+        case "anthropic":
+            return "/messages";
+        case "openai-responses":
+            return "/responses";
+    }
+}
+/** Hub Chat Completions request → upstream body for the target format. */
+export function chatRequestToUpstream(format, chat) {
+    switch (format) {
+        case "openai-chat":
+            return chat;
+        case "anthropic":
+            return chatToAnthropicRequest(chat);
+        case "openai-responses":
+            return chatToResponsesRequest(chat);
+    }
+}
+/** Upstream non-streaming payload → hub Chat Completions object. */
+export function upstreamToChatCompletion(format, payload, fallbackModel) {
+    switch (format) {
+        case "openai-chat":
+            return payload;
+        case "anthropic":
+            return anthropicMessageToChatCompletion(payload, fallbackModel);
+        case "openai-responses":
+            return responseToChatCompletion(payload, fallbackModel);
+    }
+}
+/** Hub Chat Completions object → inbound response payload. */
+export function chatCompletionToInbound(inbound, chat) {
+    switch (inbound.format) {
+        case "openai-chat":
+            return chat;
+        case "anthropic":
+            return chatCompletionToAnthropicMessage(chat, inbound.requestedModel);
+        case "openai-responses":
+            return chatCompletionToResponse(chat, inbound.requestedModel, inbound.customTools, false);
+    }
+}
+/**
+ * Overwrite the model field with the client-requested id so aliases and
+ * provider-qualified ids round-trip transparently.
+ */
+export function withRequestedModel(payload, requestedModel) {
+    if (!requestedModel)
+        return payload;
+    if (typeof payload.model === "string") {
+        return { ...payload, model: requestedModel };
+    }
+    return payload;
+}
+// --- legacy text completions --------------------------------------------------
+/** Normalize `prompt` (string | string[]) into a single user message body. */
+export function legacyPromptToChatBody(body) {
+    const prompt = body.prompt;
+    const text = Array.isArray(prompt)
+        ? prompt.map((item) => String(item)).join("\n")
+        : prompt === undefined || prompt === null
+            ? ""
+            : String(prompt);
+    const { prompt: _ignored, ...rest } = body;
+    return {
+        ...rest,
+        messages: [{ role: "user", content: text }],
+    };
+}
+function legacyText(chat) {
+    const choices = chat.choices;
+    if (!Array.isArray(choices) || !choices.length)
+        return "";
+    const message = choices[0]?.message;
+    const content = message?.content;
+    return typeof content === "string" ? content : "";
+}
+function legacyFinishReason(chat) {
+    const choices = chat.choices;
+    if (!Array.isArray(choices) || !choices.length)
+        return null;
+    const reason = choices[0]
+        ?.finish_reason;
+    return typeof reason === "string" ? reason : null;
+}
+/** Hub chat completion → legacy `text_completion` payload. */
+export function chatCompletionToLegacyCompletion(chat, requestedModel) {
+    return withRequestedModel({
+        id: typeof chat.id === "string" ? chat.id : "cmpl-gateway",
+        object: "text_completion",
+        created: typeof chat.created === "number" ? chat.created : Math.floor(Date.now() / 1000),
+        model: requestedModel,
+        choices: [
+            {
+                index: 0,
+                text: legacyText(chat),
+                logprobs: null,
+                finish_reason: legacyFinishReason(chat),
+            },
+        ],
+        ...(chat.usage ? { usage: chat.usage } : {}),
+    }, requestedModel);
+}
+/** Hub chat chunk → legacy `text_completion.chunk` payload. */
+export function chatChunkToLegacyChunk(chunk, requestedModel) {
+    const choices = Array.isArray(chunk.choices) ? chunk.choices : [];
+    const first = choices[0] ?? {};
+    const delta = first.delta ?? {};
+    const text = typeof delta.content === "string" ? delta.content : "";
+    return withRequestedModel({
+        id: typeof chunk.id === "string" ? chunk.id : "cmpl-gateway",
+        object: "text_completion.chunk",
+        created: typeof chunk.created === "number"
+            ? chunk.created
+            : Math.floor(Date.now() / 1000),
+        model: requestedModel,
+        choices: [
+            {
+                index: 0,
+                text,
+                logprobs: null,
+                finish_reason: typeof first.finish_reason === "string"
+                    ? first.finish_reason
+                    : null,
+            },
+        ],
+    }, requestedModel);
+}
+export function createUpstreamDecoder(format, fallbackModel) {
+    if (format === "openai-chat") {
+        return {
+            push(line) {
+                const parsed = parseChatSseLine(line);
+                if (!parsed || parsed === "done")
+                    return [];
+                return [parsed];
+            },
+            finish() {
+                return [];
+            },
+        };
+    }
+    if (format === "anthropic") {
+        const state = createAnthropicToChatStreamState(fallbackModel);
+        return {
+            push(line) {
+                const parsed = parseAnthropicSseLine(line);
+                if (!parsed)
+                    return [];
+                if (parsed === "done")
+                    return forceCompleteAnthropicToChatStream(state);
+                return anthropicEventToChatChunks(parsed, state);
+            },
+            finish() {
+                return forceCompleteAnthropicToChatStream(state);
+            },
+        };
+    }
+    const state = createResponsesToChatStreamState(fallbackModel);
+    return {
+        push(line) {
+            const parsed = parseResponsesSseLine(line);
+            if (!parsed)
+                return [];
+            if (parsed === "done")
+                return forceCompleteResponsesToChatStream(state);
+            return responsesEventToChatChunks(parsed, state);
+        },
+        finish() {
+            return forceCompleteResponsesToChatStream(state);
+        },
+    };
+}
+export function createInboundEncoder(inbound) {
+    if (inbound.format === "openai-chat" && inbound.legacyCompletion) {
+        return {
+            encode(chunk) {
+                return [
+                    `data: ${JSON.stringify(chatChunkToLegacyChunk(chunk, inbound.requestedModel))}\n\n`,
+                ];
+            },
+            finish() {
+                return ["data: [DONE]\n\n"];
+            },
+        };
+    }
+    if (inbound.format === "openai-chat") {
+        return {
+            encode(chunk) {
+                return [`data: ${JSON.stringify(chunk)}\n\n`];
+            },
+            finish() {
+                return ["data: [DONE]\n\n"];
+            },
+        };
+    }
+    if (inbound.format === "anthropic") {
+        const state = createAnthropicStreamState(inbound.requestedModel);
+        return {
+            encode(chunk) {
+                return chatChunkToAnthropicEvents(chunk, state);
+            },
+            finish() {
+                return forceCompleteAnthropicStream(state);
+            },
+        };
+    }
+    const state = createStreamState(inbound.requestedModel, undefined, inbound.customTools, false);
+    return {
+        encode(chunk) {
+            return chatChunkToResponsesEvents(chunk, state);
+        },
+        finish() {
+            return forceCompleteStream(state);
+        },
+    };
+}
+/** Render an error in the inbound protocol's own error shape. */
+export function formatErrorBody(format, status, message, code = "gateway_error") {
+    if (format === "anthropic") {
+        return {
+            status,
+            payload: {
+                type: "error",
+                error: { type: anthropicErrorType(status, code), message },
+            },
+        };
+    }
+    return {
+        status,
+        payload: {
+            error: {
+                message,
+                type: openAiErrorType(status),
+                code,
+                param: null,
+            },
+        },
+    };
+}
+function openAiErrorType(status) {
+    if (status === 401 || status === 403)
+        return "authentication_error";
+    if (status === 404)
+        return "invalid_request_error";
+    if (status === 429)
+        return "rate_limit_error";
+    if (status >= 500)
+        return "api_error";
+    return "invalid_request_error";
+}
+function anthropicErrorType(status, code) {
+    if (status === 401)
+        return "authentication_error";
+    if (status === 403)
+        return "permission_error";
+    if (status === 404)
+        return "not_found_error";
+    if (status === 413)
+        return "request_too_large";
+    if (status === 429)
+        return "rate_limit_error";
+    if (status === 529)
+        return "overloaded_error";
+    if (status >= 500)
+        return "api_error";
+    return code === "invalid_json" ? "invalid_request_error" : "invalid_request_error";
+}
+/** Wrap an upstream error payload so the client sees its own protocol shape. */
+export function translateUpstreamError(inboundFormat, status, rawBody) {
+    let message = rawBody.slice(0, 1000);
+    try {
+        const parsed = JSON.parse(rawBody);
+        const error = parsed.error;
+        if (error && typeof error === "object") {
+            const row = error;
+            if (typeof row.message === "string")
+                message = row.message;
+        }
+        else if (typeof parsed.message === "string") {
+            message = parsed.message;
+        }
+    }
+    catch {
+        // Non-JSON upstream error; keep the truncated raw text.
+    }
+    return formatErrorBody(inboundFormat, status, message, "upstream_error");
+}