@synapseia-network/node 0.8.5

package/dist/chunk-5QFTU52A.js

@@ -0,0 +1,442 @@
+import { fileURLToPath as __synFup } from "url";import { dirname as __synDn } from "path";const __filename = __synFup(import.meta.url);const __dirname = __synDn(__filename);
+import {
+  init_logger,
+  logger_default
+} from "./chunk-V2L5SXTL.js";
+import {
+  __name
+} from "./chunk-D7ADMHK2.js";
+
+// src/modules/model/trainer.ts
+init_logger();
+import { Injectable } from "@nestjs/common";
+import { spawn } from "child_process";
+import { existsSync } from "fs";
+import { resolve } from "path";
+import { totalmem } from "os";
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+function moduleDir() {
+  return __dirname;
+}
+__name(moduleDir, "moduleDir");
+var TRAINING_MEM_FLOOR_MB = 900;
+var TRAINER_EVAL_FAILED_SENTINEL = 1e30;
+function readTrainingHeadroomMB() {
+  const totalMB = totalmem() / (1024 * 1024);
+  const rssMB = process.memoryUsage().rss / (1024 * 1024);
+  return Math.max(0, Math.floor(totalMB - rssMB));
+}
+__name(readTrainingHeadroomMB, "readTrainingHeadroomMB");
+var TrainerHelper = class _TrainerHelper {
+  static {
+    __name(this, "TrainerHelper");
+  }
+  static pyTorchCache = null;
+  static trainingInProgress = false;
+  async isPyTorchAvailable() {
+    if (_TrainerHelper.pyTorchCache === true) return true;
+    const result = await new Promise((res) => {
+      const proc = spawn("python3", [
+        "-c",
+        "import torch; print(torch.__version__)"
+      ], {
+        stdio: [
+          "ignore",
+          "pipe",
+          "pipe"
+        ]
+      });
+      let settled = false;
+      const settle = /* @__PURE__ */ __name((v) => {
+        if (!settled) {
+          settled = true;
+          res(v);
+        }
+      }, "settle");
+      proc.on("close", (code) => settle(code === 0));
+      proc.on("error", () => settle(false));
+      setTimeout(() => {
+        try {
+          proc.kill();
+        } catch {
+        }
+        settle(false);
+      }, 3e4);
+    });
+    if (result) _TrainerHelper.pyTorchCache = true;
+    return result;
+  }
+  async trainMicroModel(options) {
+    if (_TrainerHelper.trainingInProgress) {
+      throw new Error("A training run is already in progress on this node \u2014 refusing concurrent execution");
+    }
+    _TrainerHelper.trainingInProgress = true;
+    try {
+      return await this.trainMicroModelInner(options);
+    } finally {
+      _TrainerHelper.trainingInProgress = false;
+    }
+  }
+  validateTrainingConfig(proposal) {
+    const { hyperparams } = proposal;
+    if (hyperparams.learningRate < 1e-4 || hyperparams.learningRate > 0.01) return {
+      valid: false,
+      error: "learningRate must be between 0.0001 and 0.01"
+    };
+    if (![
+      16,
+      32,
+      64,
+      128
+    ].includes(hyperparams.batchSize)) return {
+      valid: false,
+      error: "batchSize must be one of: 16, 32, 64, 128"
+    };
+    if (![
+      64,
+      128,
+      192,
+      256
+    ].includes(hyperparams.hiddenDim)) return {
+      valid: false,
+      error: "hiddenDim must be one of: 64, 128, 192, 256"
+    };
+    if (hyperparams.numLayers < 2 || hyperparams.numLayers > 8) return {
+      valid: false,
+      error: "numLayers must be between 2 and 8"
+    };
+    if (![
+      2,
+      4,
+      8
+    ].includes(hyperparams.numHeads)) return {
+      valid: false,
+      error: "numHeads must be one of: 2, 4, 8"
+    };
+    if (![
+      "gelu",
+      "silu",
+      "relu"
+    ].includes(hyperparams.activation)) return {
+      valid: false,
+      error: "activation must be one of: gelu, silu, relu"
+    };
+    if (![
+      "layernorm",
+      "rmsnorm"
+    ].includes(hyperparams.normalization)) return {
+      valid: false,
+      error: "normalization must be one of: layernorm, rmsnorm"
+    };
+    if (![
+      "xavier",
+      "kaiming",
+      "normal"
+    ].includes(hyperparams.initScheme)) return {
+      valid: false,
+      error: "initScheme must be one of: xavier, kaiming, normal"
+    };
+    if (hyperparams.maxTrainSeconds < 10 || hyperparams.maxTrainSeconds > 300) return {
+      valid: false,
+      error: "maxTrainSeconds must be between 10 and 300"
+    };
+    return {
+      valid: true
+    };
+  }
+  calculateImprovement(currentLoss, bestLoss) {
+    if (bestLoss <= 0) return 0;
+    return (bestLoss - currentLoss) / bestLoss * 100;
+  }
+  // ── Private ───────────────────────────────────────────────────────────────
+  /**
+  * Ask Ollama to unload every currently-loaded model so its weights free RAM
+  * before we spawn Python + torch. Uses /api/ps to list residents, then posts
+  * {model, keep_alive: 0} to /api/generate for each (Ollama interprets
+  * keep_alive=0 as "unload now"). Fully best-effort: 2s total budget, every
+  * error swallowed — a stale Ollama must never block training.
+  */
+  async unloadOllamaModels() {
+    const baseUrl = process.env.OLLAMA_URL ?? "http://localhost:11434";
+    const deadline = Date.now() + 2e3;
+    try {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), Math.max(500, deadline - Date.now()));
+      const listRes = await fetch(`${baseUrl}/api/ps`, {
+        signal: controller.signal
+      });
+      clearTimeout(timer);
+      if (!listRes.ok) return;
+      const listJson = await listRes.json();
+      const loaded = (listJson.models ?? []).map((m) => m.name ?? m.model).filter((n) => typeof n === "string" && n.length > 0);
+      if (loaded.length === 0) return;
+      logger_default.log(`[trainer] unloading ${loaded.length} ollama model(s) to free RAM: ${loaded.join(", ")}`);
+      await Promise.all(loaded.map(async (name) => {
+        const ctl = new AbortController();
+        const t = setTimeout(() => ctl.abort(), Math.max(300, deadline - Date.now()));
+        try {
+          await fetch(`${baseUrl}/api/generate`, {
+            method: "POST",
+            headers: {
+              "content-type": "application/json"
+            },
+            body: JSON.stringify({
+              model: name,
+              keep_alive: 0,
+              prompt: ""
+            }),
+            signal: ctl.signal
+          });
+        } catch {
+        } finally {
+          clearTimeout(t);
+        }
+      }));
+    } catch {
+    }
+  }
+  /**
+  * Estimate the resident-set memory the training spawn will need and
+  * compare to current free RAM. Heuristic, deliberately conservative:
+  *
+  *   python+torch import      ≈ 900 MB (fixed; observed range 700–900 MB
+  *                              before the user model is touched, see
+  *                              SIGKILL post-mortem 2026-04-30)
+  *   model params (fp32)      ≈ hiddenDim² × numLayers × 12 × 4 bytes
+  *   Adam state               ≈ 2× params
+  *   activations              ≈ batchSize × 256 (seq) × hiddenDim × numLayers × 4 bytes
+  *
+  * `numHeads` and the few other knobs don't move the RSS needle enough
+  * to bother modeling. The 50% safety multiplier below covers transient
+  * spikes (torch graph compilation, dataloader prefetch) that the static
+  * estimate misses; previously the pre-check passed yet the cgroup OOM
+  * killer still SIGKILL'd at runtime — bump tightens that gap.
+  */
+  checkMemoryHeadroom(hp) {
+    const SEQ_LEN = 256;
+    const FLOAT_BYTES = 4;
+    const paramsBytes = hp.hiddenDim * hp.hiddenDim * hp.numLayers * 12 * FLOAT_BYTES;
+    const adamBytes = paramsBytes * 2;
+    const activationsBytes = hp.batchSize * SEQ_LEN * hp.hiddenDim * hp.numLayers * FLOAT_BYTES;
+    const estimatedMB = Math.round(TRAINING_MEM_FLOOR_MB + (paramsBytes + adamBytes + activationsBytes) / (1024 * 1024));
+    const freeMB = readTrainingHeadroomMB();
+    const totalMB = Math.round(totalmem() / (1024 * 1024));
+    const requiredMB = Math.round(estimatedMB * 1.5);
+    return {
+      ok: freeMB >= requiredMB,
+      freeMB,
+      totalMB,
+      estimatedMB
+    };
+  }
+  resolveTrainScript() {
+    try {
+      const here = moduleDir();
+      const candidates = [
+        resolve(here, "scripts/train_micro.py"),
+        resolve(here, "../scripts/train_micro.py"),
+        resolve(here, "../../scripts/train_micro.py"),
+        resolve(here, "../../../scripts/train_micro.py"),
+        resolve(here, "../../../../scripts/train_micro.py"),
+        resolve(process.cwd(), "scripts/train_micro.py")
+      ];
+      for (const c of candidates) {
+        if (existsSync(c)) return c;
+      }
+      return candidates[0];
+    } catch {
+      return resolve(moduleDir(), "scripts/train_micro.py");
+    }
+  }
+  async trainMicroModelInner(options) {
+    const { proposal, datasetPath, hardware, pythonScriptPath = this.resolveTrainScript(), runNumber = 1 } = options;
+    const TRAINING_TIMEOUT_MS = parseInt(process.env.TRAINING_TIMEOUT_MS || "1200000", 10);
+    await this.unloadOllamaModels().catch(() => {
+    });
+    const memCheck = this.checkMemoryHeadroom(proposal.hyperparams);
+    if (!memCheck.ok) {
+      throw new Error(`Insufficient memory for training: free=${memCheck.freeMB}MB, estimated need=${memCheck.estimatedMB}MB (hiddenDim=${proposal.hyperparams.hiddenDim}, batchSize=${proposal.hyperparams.batchSize}, numLayers=${proposal.hyperparams.numLayers}, total=${memCheck.totalMB}MB). Free RAM (raise mem_limit), or wait for other processes to release memory.`);
+    }
+    let killProcess = null;
+    const settledHolder = {
+      current: false
+    };
+    const freememAtSpawnMB = readTrainingHeadroomMB();
+    const totalMemMB = Math.round(totalmem() / (1024 * 1024));
+    const trainingPromise = new Promise((res, reject) => {
+      const startTime = Date.now();
+      const lossCurve = [];
+      logger_default.log(`Spawning: python3 ${pythonScriptPath}`);
+      logger_default.log(`Training timeout: ${(TRAINING_TIMEOUT_MS / 1e3).toFixed(0)}s (TRAINING_TIMEOUT_MS env var overrides)`);
+      logger_default.log(`Script exists: ${existsSync(pythonScriptPath)}`);
+      logger_default.log(`Memory at spawn: free=${freememAtSpawnMB}MB / total=${totalMemMB}MB`);
+      const pythonProcess = spawn("python3", [
+        "-u",
+        pythonScriptPath
+      ], {
+        stdio: [
+          "pipe",
+          "pipe",
+          "pipe"
+        ],
+        env: {
+          ...process.env,
+          OMP_NUM_THREADS: "1",
+          MKL_NUM_THREADS: "1",
+          OPENBLAS_NUM_THREADS: "1",
+          NUMEXPR_NUM_THREADS: "1",
+          VECLIB_MAXIMUM_THREADS: "1"
+        }
+      });
+      killProcess = /* @__PURE__ */ __name(() => {
+        if (!pythonProcess.killed) pythonProcess.kill("SIGTERM");
+      }, "killProcess");
+      const hyperparamsPayload = {
+        ...proposal.hyperparams,
+        dataPath: datasetPath,
+        hardware
+      };
+      const settle = /* @__PURE__ */ __name((err, result) => {
+        if (settledHolder.current) return;
+        settledHolder.current = true;
+        killProcess = null;
+        if (err) reject(err);
+        else res(result);
+      }, "settle");
+      pythonProcess.on("error", (error) => {
+        settle(new Error(`Failed to spawn python3: ${error.message}. Is python3 installed?`));
+      });
+      pythonProcess.stdin.on("error", (err) => {
+        if (err.code !== "EPIPE") logger_default.warn(`[trainer] stdin error: ${err.message}`);
+      });
+      const payload = JSON.stringify(hyperparamsPayload);
+      logger_default.log(`Sending payload (${payload.length} bytes): dataPath=${hyperparamsPayload.dataPath}, hardware=${hyperparamsPayload.hardware}`);
+      pythonProcess.stdin.write(payload);
+      pythonProcess.stdin.end();
+      let stdout = "";
+      let stderr = "";
+      let finalResult = null;
+      pythonProcess.stdout.on("data", (data) => {
+        const lines = data.toString().split("\n").filter((line) => line.trim());
+        for (const line of lines) {
+          try {
+            const parsed = JSON.parse(line);
+            if (parsed.step !== void 0 && parsed.loss !== void 0) lossCurve.push(parsed.loss);
+            if (parsed.result) {
+              finalResult = {
+                finalLoss: parsed.result.finalLoss,
+                valLoss: parsed.result.valLoss,
+                // New 2026-05-05: trainer emits these when val set was empty
+                // or deadline beat the first batch. Propagated to executor so
+                // `improved` gating and reward payout can short-circuit on
+                // failed eval rather than trusting the 1e30 sentinel.
+                valLossEvalFailed: parsed.result.valLossEvalFailed === true,
+                valLossEvalFailureReason: typeof parsed.result.valLossEvalFailureReason === "string" ? parsed.result.valLossEvalFailureReason : void 0
+              };
+            }
+          } catch {
+          }
+        }
+        stdout += data.toString();
+      });
+      let stderrLineBuf = "";
+      const classifyAndLog = /* @__PURE__ */ __name((line) => {
+        const trimmed = line.trim();
+        if (!trimmed) return;
+        if (trimmed.startsWith('{"stage"') || /^\{.*"stage"\s*:/.test(trimmed)) {
+          logger_default.info(`[trainer] python3 trace: ${trimmed}`);
+          return;
+        }
+        if (/Error:|Traceback/.test(trimmed)) {
+          logger_default.error(`[trainer] python3 stderr: ${trimmed}`);
+          return;
+        }
+        if (/WARNING:/.test(trimmed)) {
+          logger_default.warn(`[trainer] python3 stderr: ${trimmed}`);
+          return;
+        }
+        logger_default.warn(`[trainer] python3 stderr: ${trimmed}`);
+      }, "classifyAndLog");
+      pythonProcess.stderr.on("data", (data) => {
+        const chunk = data.toString();
+        stderr += chunk;
+        stderrLineBuf += chunk;
+        const nl = stderrLineBuf.lastIndexOf("\n");
+        if (nl < 0) return;
+        const complete = stderrLineBuf.slice(0, nl);
+        stderrLineBuf = stderrLineBuf.slice(nl + 1);
+        for (const line of complete.split("\n")) classifyAndLog(line);
+      });
+      pythonProcess.on("close", (code, signal) => {
+        const durationMs = Date.now() - startTime;
+        if (stderrLineBuf.trim()) {
+          classifyAndLog(stderrLineBuf);
+          stderrLineBuf = "";
+        }
+        if (code === null || code !== 0) {
+          const killedByOom = code === null && signal === "SIGKILL";
+          const base = stderr.trim() ? `Training failed (exit ${code}, signal ${signal ?? "none"}): ${stderr.trim().slice(0, 500)}` : `Training process exited with code ${code ?? "null"}, signal ${signal ?? "none"} \u2014 no output received`;
+          const oomContext = killedByOom ? ` \u2014 likely OOM (SIGKILL by cgroup). hiddenDim=${proposal.hyperparams.hiddenDim}, batchSize=${proposal.hyperparams.batchSize}, numLayers=${proposal.hyperparams.numLayers}; memAtSpawn=${freememAtSpawnMB}MB/${totalMemMB}MB. Raise container mem_limit or lower hiddenDim/batchSize.` : "";
+          settle(new Error(base + oomContext));
+          return;
+        }
+        if (!finalResult) {
+          settle(new Error("Training completed but no result received from Python script"));
+          return;
+        }
+        settle(void 0, {
+          runNumber,
+          finalLoss: finalResult.finalLoss ?? 0,
+          valLoss: finalResult.valLoss ?? 0,
+          improvementPercent: 0,
+          durationMs,
+          config: proposal.hyperparams,
+          lossCurve,
+          hardwareUsed: hardware,
+          valLossEvalFailed: finalResult.valLossEvalFailed === true,
+          valLossEvalFailureReason: finalResult.valLossEvalFailureReason
+        });
+      });
+    });
+    const timeoutPromise = new Promise((_res, reject) => {
+      const timeoutHandle = setTimeout(() => {
+        settledHolder.current = true;
+        if (killProcess) {
+          killProcess();
+          killProcess = null;
+        }
+        reject(new Error(`Training timed out after ${TRAINING_TIMEOUT_MS / 1e3}s`));
+      }, TRAINING_TIMEOUT_MS);
+      trainingPromise.finally(() => clearTimeout(timeoutHandle)).catch(() => {
+      });
+    });
+    return await Promise.race([
+      trainingPromise,
+      timeoutPromise
+    ]);
+  }
+};
+TrainerHelper = _ts_decorate([
+  Injectable()
+], TrainerHelper);
+var _trainerInstance = new TrainerHelper();
+var isPyTorchAvailable = /* @__PURE__ */ __name(() => _trainerInstance.isPyTorchAvailable(), "isPyTorchAvailable");
+var trainMicroModel = /* @__PURE__ */ __name((options) => _trainerInstance.trainMicroModel(options), "trainMicroModel");
+var validateTrainingConfig = /* @__PURE__ */ __name((proposal) => _trainerInstance.validateTrainingConfig(proposal), "validateTrainingConfig");
+var calculateImprovement = /* @__PURE__ */ __name((currentLoss, bestLoss) => _trainerInstance.calculateImprovement(currentLoss, bestLoss), "calculateImprovement");
+
+export {
+  TRAINING_MEM_FLOOR_MB,
+  TRAINER_EVAL_FAILED_SENTINEL,
+  TrainerHelper,
+  isPyTorchAvailable,
+  trainMicroModel,
+  validateTrainingConfig,
+  calculateImprovement
+};

package/dist/chunk-5ZAJBIAV.js

@@ -0,0 +1,25 @@
+import { fileURLToPath as __synFup } from "url";import { dirname as __synDn } from "path";const __filename = __synFup(import.meta.url);const __dirname = __synDn(__filename);
+import {
+  __name
+} from "./chunk-D7ADMHK2.js";
+
+// src/modules/inference/chat-inference-state.ts
+var active = 0;
+function beginChatInference() {
+  active += 1;
+}
+__name(beginChatInference, "beginChatInference");
+function endChatInference() {
+  active = Math.max(0, active - 1);
+}
+__name(endChatInference, "endChatInference");
+function isChatInferenceActive() {
+  return active > 0;
+}
+__name(isChatInferenceActive, "isChatInferenceActive");
+
+export {
+  beginChatInference,
+  endChatInference,
+  isChatInferenceActive
+};

package/dist/chunk-7FLDR5NT.js

@@ -0,0 +1,186 @@
+import { fileURLToPath as __synFup } from "url";import { dirname as __synDn } from "path";const __filename = __synFup(import.meta.url);const __dirname = __synDn(__filename);
+import {
+  MODEL_CATALOG,
+  ModelCatalogHelper
+} from "./chunk-PRVT22SM.js";
+import {
+  init_logger,
+  logger_default
+} from "./chunk-V2L5SXTL.js";
+import {
+  __esm,
+  __name
+} from "./chunk-D7ADMHK2.js";
+
+// src/utils/node-auth.ts
+import * as ed from "@noble/ed25519";
+import { sha256, sha512 } from "@noble/hashes/sha2.js";
+async function buildAuthHeaders(params) {
+  const { method, path, body, privateKey, publicKey, peerId } = params;
+  const timestamp = Date.now();
+  const bodyStr = typeof body === "object" && body !== null ? JSON.stringify(sortObjectKeys(body)) : String(body ?? "");
+  const bodyHash = Buffer.from(sha256(new TextEncoder().encode(bodyStr))).toString("base64");
+  const message = `${peerId}:${timestamp}:${path}:${bodyHash}`;
+  const messageBytes = new TextEncoder().encode(message);
+  const signature = sign(messageBytes, privateKey);
+  return {
+    "X-Peer-Id": peerId,
+    "X-Public-Key": Buffer.from(publicKey).toString("base64"),
+    "X-Timestamp": String(timestamp),
+    "X-Signature": Buffer.from(signature).toString("base64")
+  };
+}
+function rawEd25519Key(buf) {
+  if (buf.length === 32) return buf;
+  if (buf.length < 32) {
+    throw new Error(`rawEd25519Key: input too short (${buf.length} bytes)`);
+  }
+  return buf.slice(buf.length - 32);
+}
+function buildWsHandshakeAuth(params) {
+  const { peerId } = params;
+  const privateKeyRaw = rawEd25519Key(params.privateKey);
+  const publicKeyRaw = rawEd25519Key(params.publicKey);
+  const timestamp = Date.now();
+  const message = `${timestamp}:websocket:handshake`;
+  const messageBytes = new TextEncoder().encode(message);
+  const signature = sign(messageBytes, privateKeyRaw);
+  return {
+    peerId,
+    publicKey: Buffer.from(publicKeyRaw).toString("hex"),
+    timestamp: String(timestamp),
+    signature: Buffer.from(signature).toString("hex")
+  };
+}
+function sortObjectKeys(obj) {
+  if (Array.isArray(obj)) {
+    return obj.map(sortObjectKeys);
+  }
+  if (typeof obj === "object" && obj !== null) {
+    return Object.keys(obj).sort().reduce((acc, key) => {
+      acc[key] = sortObjectKeys(obj[key]);
+      return acc;
+    }, {});
+  }
+  return obj;
+}
+var sign;
+var init_node_auth = __esm({
+  "src/utils/node-auth.ts"() {
+    "use strict";
+    ed.hashes.sha512 = sha512;
+    ({ sign } = ed);
+    __name(buildAuthHeaders, "buildAuthHeaders");
+    __name(rawEd25519Key, "rawEd25519Key");
+    __name(buildWsHandshakeAuth, "buildWsHandshakeAuth");
+    __name(sortObjectKeys, "sortObjectKeys");
+  }
+});
+
+// src/modules/discovery/model-discovery.ts
+init_logger();
+import axios from "axios";
+import { Injectable } from "@nestjs/common";
+init_node_auth();
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+var ModelDiscovery = class {
+  static {
+    __name(this, "ModelDiscovery");
+  }
+  lastRegisteredHash = "";
+  /**
+  * Discover locally available models and register them with the coordinator.
+  * Called periodically after heartbeat to keep the model registry in sync.
+  */
+  async registerModels(coordinatorUrl, peerId, hardware, identity, ollamaUrl) {
+    try {
+      const catalogHelper = new ModelCatalogHelper();
+      const localModelNames = catalogHelper.getLocalModels(ollamaUrl);
+      if (localModelNames.length === 0) {
+        logger_default.log("[ModelDiscovery] No local models found, skipping registration");
+        return;
+      }
+      const models = this.buildModelList(localModelNames, hardware);
+      const hash = this.hashModels(models);
+      const payload = {
+        peerId,
+        models,
+        inferencePort: Number(process.env.INFERENCE_PORT) || 8080,
+        inferencePublicUrl: process.env.INFERENCE_PUBLIC_URL || void 0
+      };
+      const modelsChanged = hash !== this.lastRegisteredHash;
+      const headers = {
+        "Content-Type": "application/json"
+      };
+      if (identity?.privateKey && identity?.publicKey) {
+        try {
+          const auth = await buildAuthHeaders({
+            method: "POST",
+            path: "/inference/register",
+            body: payload,
+            privateKey: Buffer.from(identity.privateKey, "hex"),
+            publicKey: Buffer.from(identity.publicKey, "hex"),
+            peerId: identity.peerId
+          });
+          Object.assign(headers, auth);
+        } catch (signErr) {
+          logger_default.warn("[ModelDiscovery] Failed to sign request:", signErr.message);
+        }
+      }
+      await axios.post(`${coordinatorUrl}/inference/register`, payload, {
+        timeout: 5e3,
+        headers
+      });
+      if (modelsChanged) {
+        this.lastRegisteredHash = hash;
+        logger_default.log(`[ModelDiscovery] Registered ${models.length} model(s) with coordinator`);
+      }
+    } catch (error) {
+      logger_default.warn(`[ModelDiscovery] Failed to register models: ${error.message}`);
+    }
+  }
+  /**
+  * Build model info list matching coordinator's expected format.
+  */
+  buildModelList(localModelNames, hardware) {
+    return localModelNames.map((name) => {
+      const catalogEntry = MODEL_CATALOG.find((m) => m.name.toLowerCase() === name.split(":")[0].toLowerCase());
+      const capabilities = [];
+      if (catalogEntry?.category === "embedding") {
+        capabilities.push("embedding");
+      } else {
+        capabilities.push("inference");
+        if (catalogEntry?.category === "code") capabilities.push("code");
+      }
+      return {
+        name: name.split(":")[0],
+        quantization: name.includes(":") ? name.split(":")[1] : "default",
+        vram: catalogEntry?.minVram ?? 0,
+        maxContextLength: catalogEntry?.minVram && catalogEntry.minVram >= 4 ? 8192 : 4096,
+        capabilities
+      };
+    });
+  }
+  /**
+  * Simple hash of model names for change detection.
+  */
+  hashModels(models) {
+    return models.map((m) => `${m.name}:${m.quantization}`).sort().join(",");
+  }
+};
+ModelDiscovery = _ts_decorate([
+  Injectable()
+], ModelDiscovery);
+
+export {
+  buildAuthHeaders,
+  buildWsHandshakeAuth,
+  init_node_auth,
+  ModelDiscovery
+};