@nvae/llmswitch 0.2.0 → 0.4.0

package/dist/bridge/transport.js

@@ -0,0 +1,439 @@
+import { Buffer } from "node:buffer";
+import { request as httpRequest } from "node:http";
+import { request as httpsRequest } from "node:https";
+import { HttpsProxyAgent } from "https-proxy-agent";
+import { SocksProxyAgent } from "socks-proxy-agent";
+const SUPPORTED_TARGET_PROTOCOLS = new Set(["http:", "https:"]);
+const SUPPORTED_PROXY_PROTOCOLS = new Set([
+    "http:",
+    "https:",
+    "socks:",
+    "socks4:",
+    "socks4a:",
+    "socks5:",
+    "socks5h:",
+]);
+/** Hop-by-hop and inbound-credential headers never forwarded upstream. */
+const STRIPPED_REQUEST_HEADERS = new Set([
+    "connection",
+    "keep-alive",
+    "proxy-authenticate",
+    "proxy-authorization",
+    "te",
+    "trailer",
+    "transfer-encoding",
+    "upgrade",
+    "host",
+    "content-length",
+]);
+const DEFAULT_CONNECT_TIMEOUT_MS = 30_000;
+const DEFAULT_IDLE_TIMEOUT_MS = 90_000;
+const DEFAULT_TOTAL_TIMEOUT_MS = 600_000;
+const DEFAULT_MAX_REDIRECTS = 5;
+export class TransportTimeoutError extends Error {
+    constructor(message = "上游请求超时") {
+        super(message);
+        this.name = "TransportTimeoutError";
+    }
+}
+export class ResponseLimitError extends Error {
+    constructor(message = "上游响应超出大小限制") {
+        super(message);
+        this.name = "ResponseLimitError";
+    }
+}
+export class CrossOriginRedirectError extends Error {
+    constructor(message = "拒绝跨源 redirect") {
+        super(message);
+        this.name = "CrossOriginRedirectError";
+    }
+}
+export class TransportProtocolError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "TransportProtocolError";
+    }
+}
+/**
+ * Resolve the proxy URL for a target. A profile has a single proxy applied to
+ * all traffic; the URL scheme (http/https/socks*) selects the agent.
+ */
+export function selectProxyUrl(_target, proxy) {
+    const chosen = proxy?.trim();
+    return chosen || null;
+}
+/**
+ * Build a fresh per-request Agent for the given proxy URL. Callers own its
+ * lifecycle and must call `.destroy()` once the response is drained.
+ */
+export function createTransportAgent(_target, proxyUrl) {
+    let proxy;
+    try {
+        proxy = new URL(proxyUrl);
+    }
+    catch {
+        throw new TransportProtocolError(`无效的 proxy URL: ${proxyUrl}`);
+    }
+    if (!SUPPORTED_PROXY_PROTOCOLS.has(proxy.protocol)) {
+        throw new TransportProtocolError(`不支持的 proxy protocol: ${proxy.protocol}`);
+    }
+    if (proxy.protocol === "http:" || proxy.protocol === "https:") {
+        return new HttpsProxyAgent(proxy);
+    }
+    // socks5 resolves DNS locally; socks5h/socks4a defer to the proxy.
+    return new SocksProxyAgent(proxy);
+}
+function sanitizeHeaders(headers) {
+    const out = {};
+    if (!headers)
+        return out;
+    for (const [key, value] of Object.entries(headers)) {
+        if (value === undefined)
+            continue;
+        if (STRIPPED_REQUEST_HEADERS.has(key.toLowerCase()))
+            continue;
+        out[key] = value;
+    }
+    return out;
+}
+function isSameOrigin(a, b) {
+    return (a.protocol === b.protocol && a.hostname === b.hostname && a.port === b.port);
+}
+/**
+ * A Web-`Response`-like view. Consume the body exactly once: either as a
+ * stream (`body`) for SSE pass-through, or buffered (`text`/`json`/
+ * `arrayBuffer`) with the response size limit enforced. Both paths re-arm the
+ * idle timer, and finalize timers/abort listener/proxy Agent on completion.
+ */
+class NodeTransportResponse {
+    status;
+    statusText;
+    headers;
+    ctx;
+    consumed = false;
+    pendingFatal = null;
+    failSink = null;
+    constructor(status, statusText, headers, ctx) {
+        this.status = status;
+        this.statusText = statusText;
+        this.headers = headers;
+        this.ctx = ctx;
+    }
+    get ok() {
+        return this.status >= 200 && this.status < 300;
+    }
+    /** Routes a fatal condition (idle/total timeout, abort) to the active consumer. */
+    fail(err) {
+        if (this.failSink)
+            this.failSink(err);
+        else
+            this.pendingFatal = err;
+    }
+    get body() {
+        if (this.consumed)
+            return null;
+        this.consumed = true;
+        const ctx = this.ctx;
+        const { res } = ctx;
+        return new ReadableStream({
+            start: (controller) => {
+                let closed = false;
+                const stop = (err) => {
+                    if (closed)
+                        return;
+                    closed = true;
+                    ctx.finalize();
+                    if (err) {
+                        res.destroy();
+                        try {
+                            controller.error(err);
+                        }
+                        catch {
+                            // already errored
+                        }
+                    }
+                    else {
+                        try {
+                            controller.close();
+                        }
+                        catch {
+                            // already closed
+                        }
+                    }
+                };
+                this.failSink = (err) => stop(err);
+                if (this.pendingFatal) {
+                    stop(this.pendingFatal);
+                    return;
+                }
+                res.on("data", (chunk) => {
+                    ctx.armIdle();
+                    controller.enqueue(new Uint8Array(chunk));
+                });
+                res.on("end", () => stop(null));
+                res.on("error", (err) => stop(err));
+                res.on("aborted", () => stop(new TransportTimeoutError("上游连接中断")));
+                res.resume();
+            },
+            cancel: () => {
+                ctx.finalize();
+                res.destroy();
+            },
+        });
+    }
+    buffered() {
+        if (this.consumed) {
+            return Promise.reject(new Error("响应 body 已被消费"));
+        }
+        this.consumed = true;
+        const ctx = this.ctx;
+        const { res } = ctx;
+        const max = ctx.maxResponseBytes;
+        return new Promise((resolve, reject) => {
+            const chunks = [];
+            let total = 0;
+            let done = false;
+            const finish = (err, buf) => {
+                if (done)
+                    return;
+                done = true;
+                ctx.finalize();
+                if (err) {
+                    res.destroy();
+                    reject(err);
+                }
+                else {
+                    resolve(buf ?? Buffer.concat(chunks));
+                }
+            };
+            this.failSink = (err) => finish(err);
+            if (this.pendingFatal) {
+                finish(this.pendingFatal);
+                return;
+            }
+            res.on("data", (chunk) => {
+                ctx.armIdle();
+                total += chunk.byteLength;
+                if (max !== undefined && total > max) {
+                    finish(new ResponseLimitError());
+                    return;
+                }
+                chunks.push(chunk);
+            });
+            res.on("end", () => finish(null, Buffer.concat(chunks)));
+            res.on("error", (err) => finish(err));
+            res.on("aborted", () => finish(new TransportTimeoutError("上游连接中断")));
+            res.resume();
+        });
+    }
+    async arrayBuffer() {
+        const buf = await this.buffered();
+        return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+    }
+    async text() {
+        return (await this.buffered()).toString("utf8");
+    }
+    async json() {
+        return JSON.parse(await this.text());
+    }
+}
+export async function requestWithNodeTransport(options) {
+    const maxRedirects = options.maxRedirects ?? DEFAULT_MAX_REDIRECTS;
+    const origin = parseTarget(options.url);
+    let current = origin;
+    for (let redirects = 0;; redirects += 1) {
+        const result = await performRequest(current, options);
+        if (result.type === "redirect" &&
+            redirects < maxRedirects &&
+            result.location) {
+            const next = parseTarget(new URL(result.location, current).toString());
+            if (!isSameOrigin(next, origin)) {
+                throw new CrossOriginRedirectError(`拒绝跨源 redirect: ${current.origin} → ${next.origin}`);
+            }
+            current = next;
+            continue;
+        }
+        if (result.type === "redirect" && redirects >= maxRedirects) {
+            throw new TransportProtocolError("redirect 次数超过上限");
+        }
+        return result.response;
+    }
+}
+function parseTarget(url) {
+    let target;
+    try {
+        target = new URL(url);
+    }
+    catch {
+        throw new TransportProtocolError(`无效的目标 URL: ${url}`);
+    }
+    if (!SUPPORTED_TARGET_PROTOCOLS.has(target.protocol)) {
+        throw new TransportProtocolError(`不支持的 target protocol: ${target.protocol}`);
+    }
+    return target;
+}
+function performRequest(target, options) {
+    const proxyUrl = selectProxyUrl(target, options.proxy);
+    const agent = proxyUrl ? createTransportAgent(target, proxyUrl) : undefined;
+    const isHttps = target.protocol === "https:";
+    const requestImpl = isHttps ? httpsRequest : httpRequest;
+    const connectTimeoutMs = options.connectTimeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS;
+    const idleTimeoutMs = options.idleTimeoutMs ?? DEFAULT_IDLE_TIMEOUT_MS;
+    const totalTimeoutMs = options.totalTimeoutMs ?? DEFAULT_TOTAL_TIMEOUT_MS;
+    const maxResponseBytes = options.maxResponseBytes;
+    const headers = sanitizeHeaders(options.headers);
+    const bodyBuffer = normalizeBody(options.body);
+    if (bodyBuffer) {
+        headers["Content-Length"] = String(bodyBuffer.byteLength);
+    }
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        let req = null;
+        const timers = new Set();
+        // Set once headers arrive; routes body-phase failures to the body reader.
+        let bodyController = null;
+        const timerBag = {
+            clearAll() {
+                for (const timer of timers)
+                    clearTimeout(timer);
+                timers.clear();
+            },
+        };
+        const cleanupAgent = () => {
+            if (agent && typeof agent.destroy === "function") {
+                agent.destroy();
+            }
+        };
+        const fail = (err) => {
+            if (settled)
+                return;
+            settled = true;
+            timerBag.clearAll();
+            if (options.signal)
+                options.signal.removeEventListener("abort", onAbort);
+            req?.destroy();
+            cleanupAgent();
+            reject(err);
+        };
+        // Fatal condition (timeout/abort): before headers reject the request
+        // promise; during the body phase reject the body reader instead.
+        const onFatal = (err) => {
+            if (bodyController)
+                bodyController.fail(err);
+            else
+                fail(err);
+        };
+        const onAbort = () => {
+            const reason = options.signal?.reason instanceof Error
+                ? options.signal.reason
+                : abortError();
+            onFatal(reason);
+        };
+        if (options.signal) {
+            if (options.signal.aborted) {
+                cleanupAgent();
+                reject(abortError());
+                return;
+            }
+            options.signal.addEventListener("abort", onAbort, { once: true });
+        }
+        const totalTimer = setTimeout(() => onFatal(new TransportTimeoutError("上游总超时")), totalTimeoutMs);
+        timers.add(totalTimer);
+        req = requestImpl({
+            protocol: target.protocol,
+            hostname: target.hostname,
+            port: target.port || (isHttps ? 443 : 80),
+            path: `${target.pathname}${target.search}`,
+            method: options.method ?? "GET",
+            headers,
+            agent,
+        }, (res) => {
+            const location = res.headers.location;
+            const status = res.statusCode ?? 0;
+            const isRedirect = status >= 300 && status < 400 && typeof location === "string";
+            if (isRedirect) {
+                // Drain and discard the redirect body, keep the connection tidy.
+                res.resume();
+                if (!settled) {
+                    settled = true;
+                    timerBag.clearAll();
+                    if (options.signal)
+                        options.signal.removeEventListener("abort", onAbort);
+                    cleanupAgent();
+                    const redirectResponse = new NodeTransportResponse(status, res.statusMessage ?? "", toHeaders(res.headers), { res, armIdle: () => undefined, finalize: () => undefined });
+                    resolve({
+                        type: "redirect",
+                        location: location,
+                        response: redirectResponse,
+                    });
+                }
+                return;
+            }
+            // Pause until a consumer (stream or buffered) attaches, so no chunk is
+            // lost between headers and consumption.
+            res.pause();
+            let idleTimer = null;
+            let finalized = false;
+            const armIdle = () => {
+                if (idleTimer) {
+                    clearTimeout(idleTimer);
+                    timers.delete(idleTimer);
+                }
+                idleTimer = setTimeout(() => bodyController?.fail(new TransportTimeoutError("上游空闲超时")), idleTimeoutMs);
+                timers.add(idleTimer);
+            };
+            const finalize = () => {
+                if (finalized)
+                    return;
+                finalized = true;
+                timerBag.clearAll();
+                if (options.signal)
+                    options.signal.removeEventListener("abort", onAbort);
+                cleanupAgent();
+            };
+            const response = new NodeTransportResponse(status, res.statusMessage ?? "", toHeaders(res.headers), { res, maxResponseBytes, armIdle, finalize });
+            bodyController = { fail: (err) => response.fail(err) };
+            armIdle();
+            if (!settled) {
+                settled = true;
+                resolve({ type: "response", response });
+            }
+        });
+        req.setTimeout(connectTimeoutMs, () => {
+            fail(new TransportTimeoutError("上游连接超时"));
+        });
+        req.on("error", (err) => fail(err));
+        if (bodyBuffer)
+            req.write(bodyBuffer);
+        req.end();
+    });
+}
+function normalizeBody(body) {
+    if (body == null)
+        return null;
+    if (Buffer.isBuffer(body))
+        return body;
+    if (typeof body === "string")
+        return Buffer.from(body, "utf8");
+    return Buffer.from(body);
+}
+function toHeaders(raw) {
+    const headers = new Headers();
+    for (const [key, value] of Object.entries(raw)) {
+        if (value === undefined)
+            continue;
+        if (Array.isArray(value)) {
+            for (const item of value)
+                headers.append(key, item);
+        }
+        else {
+            headers.set(key, value);
+        }
+    }
+    return headers;
+}
+function abortError() {
+    const err = new Error("请求已取消");
+    err.name = "AbortError";
+    return err;
+}

package/dist/commands/bridge-cmd.js

@@ -1,5 +1,6 @@
-import { ensureBridgeForProfile, isBridgeAlive, isPidRunning, readPid, runBridgeForeground, startBridgeDaemon, stopBridge, upstreamFromProfile, } from "../bridge/manager.js";
-import { bridgeBaseUrl, bridgeRootUrl, readBridgeState, writeBridgeUpstream, } from "../bridge/state.js";
+import { ensureBridgeForProfile, isBridgeAlive, isPidRunning, readPid, runBridgeForeground, startBridgeDaemon, stopBridge, } from "../bridge/manager.js";
+import { bridgeBaseUrl, bridgeRootUrl, readBridgeState, } from "../bridge/state.js";
+import { parseBridgePort } from "../bridge/runtime.js";
 import { DEFAULT_BRIDGE_HOST, DEFAULT_BRIDGE_PORT } from "../bridge/types.js";
 import { getActiveProfile, requireProfile } from "../store/profiles.js";
 import { isTool } from "../types.js";
@@ -12,25 +13,27 @@ export function registerBridgeCommand(program) {
         .description("前台运行 bridge（守护进程由 use/launch 自动拉起）")
         .option("--host <host>", "监听地址", DEFAULT_BRIDGE_HOST)
         .option("--port <port>", "监听端口", String(DEFAULT_BRIDGE_PORT))
+        .option("--allow-remote", "允许非回环监听（仍强制认证和限制）")
         .action(async (opts) => {
-        const port = Number(opts.port) || DEFAULT_BRIDGE_PORT;
-        await runBridgeForeground(opts.host || DEFAULT_BRIDGE_HOST, port);
+        const port = parseBridgePort(opts.port);
+        await runBridgeForeground(opts.host || DEFAULT_BRIDGE_HOST, port, Boolean(opts.allowRemote));
     });
     bridge
         .command("start")
         .description("后台启动 bridge")
         .option("--host <host>", "监听地址", DEFAULT_BRIDGE_HOST)
         .option("--port <port>", "监听端口", String(DEFAULT_BRIDGE_PORT))
+        .option("--allow-remote", "允许非回环监听（仍强制认证和限制）")
         .action(async (opts) => {
         const host = opts.host || DEFAULT_BRIDGE_HOST;
-        const port = Number(opts.port) || DEFAULT_BRIDGE_PORT;
-        const pid = await startBridgeDaemon(host, port);
+        const port = parseBridgePort(opts.port);
+        const pid = await startBridgeDaemon(host, port, Boolean(opts.allowRemote));
         for (let i = 0; i < 30; i++) {
-            if (await isBridgeAlive(host, port))
+            if (await isBridgeAlive())
                 break;
             await new Promise((r) => setTimeout(r, 100));
         }
-        if (!(await isBridgeAlive(host, port))) {
+        if (!(await isBridgeAlive())) {
             throw new Error("bridge 启动失败，请尝试：llms bridge serve");
         }
         console.log(`bridge 已启动 pid=${pid} ${bridgeRootUrl()}`);
@@ -106,8 +109,7 @@ export function registerBridgeCommand(program) {
         if (!profile) {
             throw new Error(`没有可用的 ${tool} profile`);
         }
-        writeBridgeUpstream(tool, upstreamFromProfile(profile, tool));
-        const base = await ensureBridgeForProfile(profile, tool);
-        console.log(`已刷新 ${tool} 上游 ${profile.name} → bridge ${base}`);
+        const connection = await ensureBridgeForProfile(profile, tool);
+        console.log(`已刷新 ${tool} 上游 ${profile.name} → bridge ${connection.baseUrl}`);
     });
 }

package/dist/commands/prompts.js

@@ -1,4 +1,5 @@
 import * as p from "@clack/prompts";
+import { normalizeProxyValue } from "../types.js";
 import { isApiFormat } from "../types.js";
 import { formatLabel, supportedFormats } from "../formats/compatibility.js";
 import { getPreset, presetsForTool } from "../presets/index.js";
@@ -294,14 +295,10 @@ export async function promptProfileDraft(tool, partial = {}) {
         apiKey = v || "";
     }
     // Proxy before model fetch so listing can go through the same upstream proxy.
-    let proxyHttp = partial.proxyHttp;
-    let proxyHttps = partial.proxyHttps;
-    let proxyAll = partial.proxyAll;
-    if (proxyHttp === undefined &&
-        proxyHttps === undefined &&
-        proxyAll === undefined) {
+    let proxyUrl = partial.proxy;
+    if (proxyUrl === undefined) {
         const wantProxy = await p.confirm({
-            message: "是否配置上游代理？（拉取模型与后续工具请求均可走 HTTP_PROXY / HTTPS_PROXY / ALL_PROXY）",
+            message: "是否配置上游代理？（拉取模型与后续该 provider 的请求都会走此代理）",
             initialValue: false,
         });
         if (p.isCancel(wantProxy)) {
@@ -309,28 +306,15 @@ export async function promptProfileDraft(tool, partial = {}) {
             process.exit(0);
         }
         if (wantProxy) {
-            proxyAll =
+            proxyUrl =
                 (await promptText({
-                    message: "ALL_PROXY（如 socks5h://127.0.0.1:1080，可留空）",
-                    placeholder: "socks5h://127.0.0.1:1080",
-                })) || undefined;
-            proxyHttp =
-                (await promptText({
-                    message: "HTTP_PROXY（可留空）",
-                    placeholder: "http://127.0.0.1:5112",
-                })) || undefined;
-            proxyHttps =
-                (await promptText({
-                    message: "HTTPS_PROXY（可留空）",
-                    placeholder: "http://127.0.0.1:5112",
+                    message: "代理地址（支持 http/https/socks5，可留空）",
+                    placeholder: "socks5://127.0.0.1:1080",
+                    validate: validateProxyUrl,
                 })) || undefined;
         }
     }
-    const proxy = buildProxyConfig({
-        http: proxyHttp,
-        https: proxyHttps,
-        all: proxyAll,
-    });
+    const proxy = buildProxyConfig({ url: proxyUrl });
     if (tool === "codex" && apiFormat === "openai-chat" && !bridgeMode) {
         bridgeMode = "chat";
     }
@@ -417,23 +401,13 @@ export async function promptEditProfile(tool, current) {
         }
         apiKey = v || "";
     }
-    const http = await promptText({
-        message: "HTTP_PROXY（留空清除）",
-        initialValue: current.proxy?.http || "",
-    });
-    const https = await promptText({
-        message: "HTTPS_PROXY（留空清除）",
-        initialValue: current.proxy?.https || "",
-    });
-    const all = await promptText({
-        message: "ALL_PROXY（留空清除）",
-        initialValue: current.proxy?.all || "",
-    });
-    const proxy = buildProxyConfig({
-        http: http || undefined,
-        https: https || undefined,
-        all: all || undefined,
+    const proxyInput = await promptText({
+        message: "代理地址（支持 http/https/socks5，留空清除）",
+        placeholder: "socks5://127.0.0.1:1080",
+        initialValue: current.proxy || "",
+        validate: validateProxyUrl,
     });
+    const proxy = buildProxyConfig({ url: proxyInput || undefined });
     const next = {
         ...current,
         displayName,
@@ -581,15 +555,37 @@ export async function tryFetchModels(input) {
         return null;
     }
 }
-export function buildProxyConfig(input) {
-    const proxy = {};
-    if (input.http?.trim())
-        proxy.http = input.http.trim();
-    if (input.https?.trim())
-        proxy.https = input.https.trim();
-    if (input.all?.trim())
-        proxy.all = input.all.trim();
-    if (!proxy.http && !proxy.https && !proxy.all)
+const SUPPORTED_PROXY_SCHEMES = [
+    "http",
+    "https",
+    "socks",
+    "socks4",
+    "socks4a",
+    "socks5",
+    "socks5h",
+];
+/**
+ * Validate a single proxy URL for the interactive prompts. Empty is allowed
+ * (clears the proxy). Returns an error message string when invalid.
+ */
+export function validateProxyUrl(value) {
+    const trimmed = value?.trim();
+    if (!trimmed)
         return undefined;
-    return proxy;
+    let url;
+    try {
+        url = new URL(trimmed);
+    }
+    catch {
+        return "代理地址格式无效，示例：http://127.0.0.1:7890 或 socks5://127.0.0.1:1080";
+    }
+    const scheme = url.protocol.replace(/:$/, "").toLowerCase();
+    if (!SUPPORTED_PROXY_SCHEMES.includes(scheme)) {
+        return `不支持的代理协议「${scheme}」。支持：http、https、socks5（含 socks/socks4/socks4a/socks5h）`;
+    }
+    return undefined;
+}
+/** Normalize a single proxy URL input into the stored value. */
+export function buildProxyConfig(input) {
+    return normalizeProxyValue(input.url);
 }

package/dist/store/profiles.js

@@ -1,6 +1,6 @@
 import { existsSync, readdirSync, unlinkSync } from "node:fs";
 import { readFileSync } from "node:fs";
-import { isApiFormat } from "../types.js";
+import { isApiFormat, normalizeProxyValue } from "../types.js";
 import { normalizeBaseUrlForFormat } from "../utils/base-url.js";
 import { atomicWriteFile, ensureDir, maskSecret } from "../utils/fs.js";
 import { getProfilePath, getProfilesDir, getStatePath, getToolStoreDir, } from "../utils/paths.js";
@@ -191,7 +191,7 @@ function normalizeProfile(raw, fallbackName) {
             fast: raw.models?.fast || undefined,
             list: list.length ? list : raw.models?.default ? [raw.models.default] : [],
         },
-        proxy: raw.proxy,
+        proxy: normalizeProxyValue(raw.proxy),
         bridgeMode: raw.bridgeMode,
         headers: raw.headers || {},
         updatedAt: raw.updatedAt || new Date(0).toISOString(),

package/dist/types.js

@@ -11,7 +11,24 @@ export function isApiFormat(value) {
     return API_FORMATS.includes(value);
 }
 export function emptyProxy(proxy) {
-    if (!proxy)
-        return true;
-    return !proxy.http && !proxy.https && !proxy.all;
+    return !proxy || !proxy.trim();
+}
+/**
+ * Coerce a stored proxy value into a single URL string. Accepts the current
+ * string form, or the legacy `{ http, https, all }` object (preferring `all`,
+ * then `https`, then `http`). Returns undefined when no proxy is set.
+ */
+export function normalizeProxyValue(raw) {
+    if (typeof raw === "string") {
+        const trimmed = raw.trim();
+        return trimmed ? trimmed : undefined;
+    }
+    if (raw && typeof raw === "object") {
+        const row = raw;
+        for (const value of [row.all, row.https, row.http]) {
+            if (typeof value === "string" && value.trim())
+                return value.trim();
+        }
+    }
+    return undefined;
 }