@omnicrawl/cli-linux-arm-musl 0.2.6 → 0.3.0

package/host/rust/assets/extensions/node_runner.mjs

@@ -0,0 +1,402 @@
+#!/usr/bin/env node
+/**
+ * OmniCrawl 单插件 Node runner。
+ *
+ * Host 固定调用：
+ *   node node_runner.mjs --plugin-root <canonical-path>
+ *
+ * 协议：stdin/stdout NDJSON JSON-RPC 2.0。
+ * 插件日志经 SDK logger 走 stderr 结构化行；普通 console 也被重定向到 stderr。
+ */
+
+import { createRequire } from "node:module";
+import path from "node:path";
+import process from "node:process";
+import { pathToFileURL } from "node:url";
+import readline from "node:readline";
+import fs from "node:fs";
+
+const require = createRequire(import.meta.url);
+
+function parseArgs(argv) {
+  const args = { pluginRoot: "" };
+  for (let i = 0; i < argv.length; i += 1) {
+    const item = argv[i];
+    if (item === "--plugin-root") {
+      args.pluginRoot = argv[i + 1] || "";
+      i += 1;
+    }
+  }
+  return args;
+}
+
+function writeStdout(message) {
+  process.stdout.write(`${JSON.stringify(message)}\n`);
+}
+
+function writeStderrLine(level, message, fields = {}) {
+  const payload = {
+    level,
+    message: String(message),
+    fields,
+    ts: new Date().toISOString(),
+  };
+  process.stderr.write(`${JSON.stringify(payload)}\n`);
+}
+
+// 强制把 console 导向 stderr，避免污染协议 stdout。
+const originalConsole = { ...console };
+for (const level of ["log", "info", "warn", "error", "debug"]) {
+  console[level] = (...parts) => {
+    writeStderrLine(level === "log" ? "info" : level, parts.map(String).join(" "));
+  };
+}
+
+function createLogger() {
+  return {
+    debug(message, fields) {
+      writeStderrLine("debug", message, fields || {});
+    },
+    info(message, fields) {
+      writeStderrLine("info", message, fields || {});
+    },
+    warn(message, fields) {
+      writeStderrLine("warn", message, fields || {});
+    },
+    error(message, fields) {
+      writeStderrLine("error", message, fields || {});
+    },
+  };
+}
+
+function definePlugin(plugin) {
+  return plugin;
+}
+
+function loadPackageJson(pluginRoot) {
+  const packagePath = path.join(pluginRoot, "package.json");
+  const raw = fs.readFileSync(packagePath, "utf8");
+  return JSON.parse(raw);
+}
+
+async function importPlugin(entryPath) {
+  const url = pathToFileURL(entryPath).href;
+  const mod = await import(url);
+  return mod.default || mod.plugin || mod;
+}
+
+class PluginRuntime {
+  constructor(pluginRoot) {
+    this.pluginRoot = path.resolve(pluginRoot);
+    this.packageJson = loadPackageJson(this.pluginRoot);
+    this.manifest = this.packageJson.omnicrawl || {};
+    this.handlers = new Map();
+    this.plugin = null;
+    this.initialized = false;
+    this.activeCancellations = new Set();
+    this.logger = createLogger();
+    this._hostRequestId = 1;
+    this._pendingHostRequests = new Map();
+  }
+
+  /** Host 对 Worker 请求的响应入口（custom.emit 等）。 */
+  resolveHostResponse(message) {
+    if (!message || message.id == null) return false;
+    const pending = this._pendingHostRequests.get(message.id);
+    if (!pending) return false;
+    this._pendingHostRequests.delete(message.id);
+    if (message.error) {
+      pending.reject(new Error(message.error.message || String(message.error)));
+    } else {
+      pending.resolve(message.result || { ok: true });
+    }
+    return true;
+  }
+
+  _requestHost(method, params = {}) {
+    const id = this._hostRequestId;
+    this._hostRequestId += 1;
+    return new Promise((resolve, reject) => {
+      this._pendingHostRequests.set(id, { resolve, reject });
+      writeStdout({
+        jsonrpc: "2.0",
+        id,
+        method,
+        params,
+      });
+      // Host 超时由 Python 侧控制；Worker 侧给一个安全兜底。
+      setTimeout(() => {
+        if (this._pendingHostRequests.has(id)) {
+          this._pendingHostRequests.delete(id);
+          reject(new Error(`Host 请求超时：${method}`));
+        }
+      }, 10000);
+    });
+  }
+
+  async initialize(params = {}) {
+    if (this.initialized) {
+      return this._registrationSnapshot();
+    }
+    const entryRel = this.manifest.entry || this.packageJson.main;
+    if (!entryRel) {
+      throw new Error("package.json 缺少 omnicrawl.entry / main");
+    }
+    const entryPath = path.resolve(this.pluginRoot, entryRel);
+    const rootResolved = path.resolve(this.pluginRoot);
+    if (!entryPath.startsWith(rootResolved + path.sep) && entryPath !== rootResolved) {
+      throw new Error(`entry 逃逸包根目录：${entryRel}`);
+    }
+
+    const imported = await importPlugin(entryPath);
+    const definition = typeof imported === "function" ? imported({ definePlugin }) : imported;
+    if (!definition || typeof definition.activate !== "function") {
+      throw new Error("插件必须导出 activate(context) 的 PluginDefinition");
+    }
+    this.plugin = definition;
+
+    const declared = Array.isArray(this.manifest.hooks) ? this.manifest.hooks : [];
+    const declaredIds = new Set(declared.map((item) => item.id));
+
+    const context = {
+      plugin: {
+        name: this.packageJson.name,
+        version: this.packageJson.version,
+        apiVersion: String(this.manifest.apiVersion || "1"),
+      },
+      runtime: {
+        omnicrawlVersion: params.omnicrawlVersion || process.env.OMNICRAWL_VERSION || "0.1.5",
+        nodeVersion: process.version,
+      },
+      hooks: {
+        on: (registration) => {
+          if (!registration || typeof registration !== "object") {
+            throw new Error("hooks.on(registration) 需要对象");
+          }
+          const id = String(registration.id || "");
+          const hook = String(registration.hook || "");
+          const mode = String(registration.mode || "observe");
+          const handler = registration.handler;
+          if (!declaredIds.has(id)) {
+            throw new Error(`运行期不能注册 manifest 未声明的 Handler：${id}`);
+          }
+          if (typeof handler !== "function") {
+            throw new Error(`Handler ${id} 缺少 handler 函数`);
+          }
+          this.handlers.set(id, { id, hook, mode, handler });
+          return () => {
+            this.handlers.delete(id);
+          };
+        },
+        emitCustom: async (event, payload = {}, options = {}) => {
+          if (!this.initialized) {
+            throw new Error("initialize 完成前不能 emitCustom");
+          }
+          const permissions = Array.isArray(this.manifest.permissions)
+            ? this.manifest.permissions
+            : [];
+          if (!permissions.includes("hook:custom-emit")) {
+            throw new Error("缺少 hook:custom-emit 权限");
+          }
+          const version =
+            options.version != null
+              ? Number(options.version)
+              : Number(
+                  (Array.isArray(this.manifest.customEvents)
+                    ? this.manifest.customEvents.find((item) => item.name === event)
+                    : null)?.version || 1
+                );
+
+          // 同插件订阅必须本地投递：Host 若在 hook.invoke 中再回调本 Worker
+          // 会与“等待 custom.emit 响应”形成死锁。
+          let localDelivered = 0;
+          const localEvent = {
+            apiVersion: String(this.manifest.apiVersion || "1"),
+            hook: event,
+            payload: payload || {},
+            timestamp: new Date().toISOString(),
+          };
+          for (const binding of this.handlers.values()) {
+            if (binding.hook !== event) continue;
+            await binding.handler(localEvent);
+            localDelivered += 1;
+          }
+
+          const result = await this._requestHost("custom.emit", {
+            event,
+            version,
+            payload: payload || {},
+            localDelivered,
+          });
+          return {
+            ...(result || { ok: true }),
+            localDelivered,
+            delivered: Number(result?.delivered || 0) + localDelivered,
+          };
+        },
+      },
+      logger: this.logger,
+    };
+
+    await definition.activate(context);
+
+    // 若插件未在 activate 中显式 on()，但 manifest 声明了 hooks，则保持空绑定；
+    // Host 会在二次校验时发现实际注册子集。
+    this.initialized = true;
+    return this._registrationSnapshot();
+  }
+
+  _registrationSnapshot() {
+    const registrations = [];
+    for (const item of this.handlers.values()) {
+      registrations.push({
+        id: item.id,
+        hook: item.hook,
+        mode: item.mode,
+      });
+    }
+    // 若 activate 没手动 on，回落为 manifest 声明（开发期便利）；
+    // Host 仍要求它们是 manifest 子集。
+    if (registrations.length === 0 && Array.isArray(this.manifest.hooks)) {
+      for (const item of this.manifest.hooks) {
+        registrations.push({
+          id: item.id,
+          hook: item.hook,
+          mode: item.mode,
+        });
+      }
+    }
+    return {
+      plugin: {
+        name: this.packageJson.name,
+        version: this.packageJson.version,
+        apiVersion: String(this.manifest.apiVersion || "1"),
+      },
+      handlers: registrations,
+      capabilities: {
+        customEmit: Boolean(
+          Array.isArray(this.manifest.permissions) &&
+            this.manifest.permissions.includes("hook:custom-emit")
+        ),
+      },
+    };
+  }
+
+  async invoke(handlerId, event) {
+    const binding = this.handlers.get(handlerId);
+    if (!binding) {
+      // 允许仅声明未绑定：默认 continue，便于 observe 空实现。
+      return { action: "continue" };
+    }
+    const result = await binding.handler(event);
+    if (result == null) {
+      return { action: "continue" };
+    }
+    if (typeof result !== "object") {
+      throw new Error(`Handler ${handlerId} 必须返回对象`);
+    }
+    return result;
+  }
+
+  async shutdown() {
+    if (this.plugin && typeof this.plugin.deactivate === "function") {
+      await this.plugin.deactivate();
+    }
+    this.handlers.clear();
+    this.initialized = false;
+  }
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (!args.pluginRoot) {
+    writeStderrLine("error", "missing --plugin-root");
+    process.exit(2);
+  }
+  const runtime = new PluginRuntime(args.pluginRoot);
+  const rl = readline.createInterface({ input: process.stdin, crlfDelay: Infinity });
+
+  const sendResult = (id, result) => {
+    writeStdout({ jsonrpc: "2.0", id, result });
+  };
+  const sendError = (id, code, message) => {
+    writeStdout({ jsonrpc: "2.0", id, error: { code, message } });
+  };
+
+  // 必须用事件驱动读取 stdin：handler 内 await custom.emit 时 Host 响应
+  // 也要从同一 stdin 进来。若 for-await 串行阻塞，会形成死锁超时。
+  let shuttingDown = false;
+  const inflight = new Set();
+
+  const handleMessage = async (message) => {
+    // Host 对 Worker 请求的响应：无 method，带 id+result/error。
+    if (
+      message.id != null &&
+      (Object.prototype.hasOwnProperty.call(message, "result") ||
+        Object.prototype.hasOwnProperty.call(message, "error")) &&
+      !message.method
+    ) {
+      runtime.resolveHostResponse(message);
+      return;
+    }
+
+    const { id, method, params } = message;
+    try {
+      if (method === "initialize") {
+        const result = await runtime.initialize(params || {});
+        if (id !== undefined) sendResult(id, result);
+      } else if (method === "hook.invoke") {
+        const handlerId = params?.handlerId;
+        const event = params?.event || {};
+        const result = await runtime.invoke(handlerId, event);
+        if (id !== undefined) sendResult(id, result);
+      } else if (method === "hook.cancel") {
+        const requestId = params?.requestId;
+        if (requestId != null) runtime.activeCancellations.add(requestId);
+        if (id !== undefined) sendResult(id, { ok: true });
+      } else if (method === "ping") {
+        if (id !== undefined) sendResult(id, { ok: true, ts: Date.now() });
+      } else if (method === "shutdown") {
+        shuttingDown = true;
+        await runtime.shutdown();
+        if (id !== undefined) sendResult(id, { ok: true });
+        process.exit(0);
+      } else if (method) {
+        if (id !== undefined) sendError(id, -32601, `Method not found: ${method}`);
+      }
+    } catch (error) {
+      const text = error instanceof Error ? error.message : String(error);
+      writeStderrLine("error", text);
+      if (id !== undefined) sendError(id, -32000, text);
+    }
+  };
+
+  rl.on("line", (line) => {
+    if (shuttingDown) return;
+    const trimmed = String(line || "").trim();
+    if (!trimmed) return;
+    let message;
+    try {
+      message = JSON.parse(trimmed);
+    } catch (error) {
+      writeStderrLine("error", "invalid json from host", { error: String(error) });
+      return;
+    }
+    if (!message || typeof message !== "object") return;
+    const task = handleMessage(message);
+    inflight.add(task);
+    task.finally(() => inflight.delete(task));
+  });
+
+  await new Promise((resolve) => {
+    rl.on("close", resolve);
+  });
+  await Promise.allSettled([...inflight]);
+}
+
+main().catch((error) => {
+  writeStderrLine("error", error instanceof Error ? error.message : String(error));
+  process.exit(1);
+});
+
+export { definePlugin };

package/host/rust/assets/extensions/onejev_worker.py

@@ -0,0 +1,293 @@
+"""OneJev 本地决策 worker：在命名管道（Windows）/ Unix socket 上提供 System One 判定。
+
+为什么不用 `qev serve`：官方那个服务经 uvicorn/FastAPI 暴露 HTTP，本机调用方因此要为
+一次纯内存判定多付一层 TCP + ASGI 中转。这个 worker 直接持有 `qev` 的引擎对象，
+请求从管道进来、答案从管道出去，中间只有一次 JSON 编解码。
+
+协议（NDJSON，一行一个 JSON 对象）：
+
+    请求   {"model": "...", "state": {...}, "questions": {...}}
+    成功   {"model": "...", "answers": {...}, "usage": {...}, "qev": {...}}
+    失败   {"error": "可读原因"}
+
+响应形状故意与 HTTP 端点一致，Rust 侧读答案的代码因此不必区分两种传输。
+
+服务是**本机共用**的常驻进程，由 OmniCrawl 宿主以脱离进程的方式拉起（见
+`omnicrawl-onejev` 的 `server` 模块）：加载权重、创建端点、打出就绪标记，之后一直服务；
+停止只能显式做（宿主按 PID 回收整棵进程树）。
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import os
+import socket
+import sys
+import threading
+import time
+from pathlib import Path
+
+# 就绪标记：宿主按它认定「服务已经能接请求」（写进服务日志）。
+READY_MARKER = "[onejev] 服务就绪"
+# 单次连接的等待上限（秒）：客户端总是连上就发，静默超时说明对端已经不在了。
+CONNECTION_TIMEOUT_SECONDS = 60.0
+# 管道缓冲区：一次判定请求的 state 上限是 64k 字符级别，留一倍余量。
+PIPE_BUFFER_BYTES = 128 * 1024
+
+log = logging.getLogger("onejev.worker")
+
+
+class Decider:
+    """引擎 + 判定；串行化——一次前向独占前缀缓存，并发只会互相踩。"""
+
+    def __init__(self, engine, model_name: str) -> None:
+        self.engine = engine
+        self.model_name = model_name
+        self._lock = threading.Lock()
+
+    def answer(self, body: dict) -> dict:
+        from qev.schema import SystemOneRequest
+
+        request = SystemOneRequest.model_validate(body)
+        with self._lock:
+            response, meta = self.engine.decide(request)
+        response.model = self.model_name
+        payload = response.model_dump()
+        payload["qev"] = meta
+        return payload
+
+
+def _handle_connection(decider: Decider, read_line, write_line, close) -> None:
+    """一次连接 = 一次判定：读一行请求，回一行响应（成功或错误），然后收线。"""
+    try:
+        line = read_line()
+        if not line:
+            return
+        payload = decider.answer(json.loads(line))
+    except Exception as error:  # 请求不合法 / 引擎报错：回一行可读原因，不猜答案
+        log.warning("判定失败：%s", error)
+        message = str(error) or error.__class__.__name__
+        try:
+            write_line(json.dumps({"error": message}, ensure_ascii=False))
+        except Exception:
+            pass
+    else:
+        write_line(json.dumps(payload, ensure_ascii=False))
+    finally:
+        close()
+
+
+# --------------------------------------------------------------------------
+# Windows：命名管道
+# --------------------------------------------------------------------------
+
+
+def windows_pipe_io(endpoint: str, decider: Decider) -> None:
+    import ctypes
+    import ctypes.wintypes as wintypes
+    import msvcrt
+
+    kernel32 = ctypes.WinDLL("kernel32", use_last_error=True)
+
+    pipe_access_duplex = 0x00000003
+    pipe_type_byte = 0x00000000
+    pipe_readmode_byte = 0x00000000
+    pipe_wait = 0x00000000
+    pipe_unlimited_instances = 255
+    invalid_handle = wintypes.HANDLE(-1).value
+    error_pipe_connected = 535
+
+    kernel32.CreateNamedPipeW.restype = wintypes.HANDLE
+    kernel32.CreateNamedPipeW.argtypes = [
+        wintypes.LPCWSTR, wintypes.DWORD, wintypes.DWORD, wintypes.DWORD,
+        wintypes.DWORD, wintypes.DWORD, wintypes.DWORD, ctypes.c_void_p,
+    ]
+    kernel32.ConnectNamedPipe.restype = wintypes.BOOL
+    kernel32.ConnectNamedPipe.argtypes = [wintypes.HANDLE, ctypes.c_void_p]
+    kernel32.PeekNamedPipe.restype = wintypes.BOOL
+    kernel32.PeekNamedPipe.argtypes = [
+        wintypes.HANDLE, ctypes.c_void_p, wintypes.DWORD,
+        ctypes.POINTER(wintypes.DWORD), ctypes.POINTER(wintypes.DWORD), ctypes.POINTER(wintypes.DWORD),
+    ]
+    kernel32.CloseHandle.restype = wintypes.BOOL
+    kernel32.CloseHandle.argtypes = [wintypes.HANDLE]
+
+    def create_instance() -> int:
+        return kernel32.CreateNamedPipeW(
+            endpoint,
+            pipe_access_duplex,
+            pipe_type_byte | pipe_readmode_byte | pipe_wait,
+            pipe_unlimited_instances,
+            PIPE_BUFFER_BYTES,
+            PIPE_BUFFER_BYTES,
+            0,
+            None,
+        )
+
+    def serve_instance(handle: int) -> None:
+        fd = msvcrt.open_osfhandle(handle, os.O_RDWR | os.O_BINARY)
+        stream = os.fdopen(fd, "r+b", buffering=0)
+
+        def read_line() -> str:
+            buffer = bytearray()
+            deadline = time.monotonic() + CONNECTION_TIMEOUT_SECONDS
+            while b"\n" not in buffer:
+                available = wintypes.DWORD(0)
+                kernel32.PeekNamedPipe(
+                    wintypes.HANDLE(handle), None, 0, None, ctypes.byref(available), None
+                )
+                if available.value:
+                    chunk = stream.read(available.value)
+                    if not chunk:
+                        break
+                    buffer += chunk
+                    continue
+                if time.monotonic() > deadline:
+                    break
+                time.sleep(0.005)
+            return bytes(buffer).split(b"\n", 1)[0].decode("utf-8", "replace")
+
+        def write_line(text: str) -> None:
+            stream.write(text.encode("utf-8") + b"\n")
+
+        # 关闭 fd 即关闭 handle（`open_osfhandle` 把它交给了 fd）。
+        _handle_connection(decider, read_line, write_line, stream.close)
+
+    # 实例先建出来再报就绪：宿主看到标记时端点必须已经能被连上。
+    first = create_instance()
+    if first == invalid_handle:
+        raise SystemExit(f"创建命名管道失败：{ctypes.get_last_error()}（{endpoint}）")
+    print(f"{READY_MARKER} endpoint={endpoint}", flush=True)
+
+    pending = first
+    while True:
+        handle = pending
+        if not kernel32.ConnectNamedPipe(wintypes.HANDLE(handle), None):
+            error = ctypes.get_last_error()
+            # ERROR_PIPE_CONNECTED 说明客户端已经连上了这个实例，照旧交给服务线程。
+            if error != error_pipe_connected:
+                kernel32.CloseHandle(wintypes.HANDLE(handle))
+                pending = create_instance()
+                continue
+        # 一个实例只服务一个连接；下一个实例提前建好，客户端不会撞到「管道不存在」。
+        pending = create_instance()
+        threading.Thread(target=serve_instance, args=(handle,), daemon=True).start()
+
+
+# --------------------------------------------------------------------------
+# Unix：Unix domain socket（没有 TCP 端口，也没有 HTTP 中转）
+# --------------------------------------------------------------------------
+
+
+def unix_socket_io(endpoint: str, decider: Decider) -> None:
+    path = Path(endpoint)
+    if path.exists():
+        path.unlink()
+    server = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+    server.bind(endpoint)
+    server.listen(64)
+    os.chmod(endpoint, 0o600)
+    print(f"{READY_MARKER} endpoint={endpoint}", flush=True)
+
+    def serve_connection(connection: socket.socket) -> None:
+        stream = connection.makefile("rwb", buffering=0)
+
+        def read_line() -> str:
+            connection.settimeout(CONNECTION_TIMEOUT_SECONDS)
+            line = stream.readline()
+            return line.decode("utf-8", "replace").rstrip("\n") if line else ""
+
+        def write_line(text: str) -> None:
+            stream.write(text.encode("utf-8") + b"\n")
+
+        def close() -> None:
+            try:
+                stream.close()
+            finally:
+                connection.close()
+
+        _handle_connection(decider, read_line, write_line, close)
+
+    while True:
+        connection, _ = server.accept()
+        threading.Thread(target=serve_connection, args=(connection,), daemon=True).start()
+
+
+# --------------------------------------------------------------------------
+# 引擎装配（与 `qev serve` 同口径，但不启 HTTP 服务）
+# --------------------------------------------------------------------------
+
+
+def build_engine(args: argparse.Namespace):
+    from qev.calibrate import Calibration
+    from qev.mm_engine import local_model_dir
+
+    model_path = local_model_dir(args.model)
+    local = Path(model_path) / "calibration.json"
+    calib_path = args.calibration or (str(local) if local.exists() else None)
+    calibration = Calibration.load(calib_path) if calib_path else None
+    if calib_path:
+        log.info("calibration: %s", calib_path)
+
+    config = json.loads((Path(model_path) / "config.json").read_text())
+    if args.multimodal or config.get("vision_config") is not None:
+        from qev.mm_engine import MMDecisionEngine
+
+        return MMDecisionEngine(
+            model_path,
+            device=args.device,
+            dtype=args.dtype,
+            calibration=calibration,
+            fork_mode=args.fork_mode,
+            head_dtype=args.head_dtype,
+            max_branch_tokens=args.max_branch_tokens,
+            max_request_tokens=args.max_request_tokens,
+            gpu_preprocess=not args.no_gpu_preprocess,
+            cuda_graphs=not args.no_cuda_graphs,
+        )
+    from qev.engine import DecisionEngine
+
+    return DecisionEngine(
+        model_path,
+        device=args.device,
+        dtype=args.dtype,
+        calibration=calibration,
+        fork_mode=args.fork_mode,
+        head_dtype=args.head_dtype,
+        max_branch_tokens=args.max_branch_tokens,
+        max_request_tokens=args.max_request_tokens,
+    )
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(prog="onejev_worker")
+    parser.add_argument("--model", required=True, help="本地权重目录（或 Hub id）")
+    parser.add_argument("--name", default=None, help="对外的模型名")
+    parser.add_argument("--endpoint", required=True, help="命名管道名或 Unix socket 路径")
+    parser.add_argument("--device", default="cuda")
+    parser.add_argument("--dtype", default="bfloat16")
+    parser.add_argument("--head-dtype", default="float32")
+    parser.add_argument("--fork-mode", default="auto")
+    parser.add_argument("--multimodal", action="store_true")
+    parser.add_argument("--no-cuda-graphs", action="store_true")
+    parser.add_argument("--no-gpu-preprocess", action="store_true")
+    parser.add_argument("--calibration", default=None)
+    parser.add_argument("--max-branch-tokens", type=int, default=32768)
+    parser.add_argument("--max-request-tokens", type=int, default=65536)
+    args = parser.parse_args()
+
+    logging.basicConfig(level=logging.INFO, format="%(asctime)s %(name)s %(levelname)s %(message)s")
+
+    engine = build_engine(args)
+    decider = Decider(engine, args.name or Path(args.model).name)
+
+    if sys.platform == "win32":
+        windows_pipe_io(args.endpoint, decider)
+    else:
+        unix_socket_io(args.endpoint, decider)
+
+
+if __name__ == "__main__":
+    main()