@synapseia-network/node 0.8.5

package/dist/chunk-C5XRYLYP.js

@@ -0,0 +1,137 @@
+import { fileURLToPath as __synFup } from "url";import { dirname as __synDn } from "path";const __filename = __synFup(import.meta.url);const __dirname = __synDn(__filename);
+import {
+  __esm,
+  __name
+} from "./chunk-D7ADMHK2.js";
+
+// src/shared/embedding.ts
+import { Injectable } from "@nestjs/common";
+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;
+}
+function _ts_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+var DEFAULT_OLLAMA_URL, EmbeddingHelper, generateEmbedding, cosineSimilarity, similaritySearch;
+var init_embedding = __esm({
+  "src/shared/embedding.ts"() {
+    __name(_ts_decorate, "_ts_decorate");
+    __name(_ts_metadata, "_ts_metadata");
+    DEFAULT_OLLAMA_URL = "http://localhost:11434";
+    EmbeddingHelper = class {
+      static {
+        __name(this, "EmbeddingHelper");
+      }
+      ollamaBaseUrl;
+      constructor(ollamaUrl) {
+        this.ollamaBaseUrl = ollamaUrl ?? process.env.OLLAMA_URL ?? DEFAULT_OLLAMA_URL;
+      }
+      /**
+      * Generate embedding vector from text via Ollama (real vectors, no mocks).
+      * Requires Ollama running locally with the target model pulled.
+      * Throws clearly if Ollama is unavailable — no silent fallbacks.
+      */
+      async generateEmbedding(text, model = "locusai/all-minilm-l6-v2") {
+        const url = `${this.ollamaBaseUrl}/api/embeddings`;
+        const payload = {
+          model,
+          prompt: text
+        };
+        let response;
+        try {
+          response = await fetch(url, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json"
+            },
+            body: JSON.stringify(payload)
+          });
+        } catch (err) {
+          throw new Error(`Cannot connect to Ollama at ${this.ollamaBaseUrl}. Is Ollama running? Start with: ollama serve. Then pull the model: ollama pull ${model}. Original error: ${err.message}`);
+        }
+        if (!response.ok) {
+          const body = await response.text().catch(() => "");
+          throw new Error(`Ollama embeddings API error ${response.status} ${response.statusText} \u2014 model="${model}", url="${url}". ` + (body.includes("model not found") || response.status === 404 ? `Model not found. Pull it with: ollama pull ${model}` : body || "Unknown error"));
+        }
+        const data = await response.json();
+        if (!Array.isArray(data.embedding) || data.embedding.length === 0) {
+          throw new Error(`Ollama returned empty embedding for model="${model}"`);
+        }
+        return data.embedding;
+      }
+      /**
+      * Compute cosine similarity between two vectors
+      */
+      cosineSimilarity(a, b) {
+        if (a.length !== b.length) {
+          throw new Error("Vectors must have same length");
+        }
+        if (a.length === 0) {
+          throw new Error("Vectors must not be empty");
+        }
+        let dotProduct = 0;
+        let normA = 0;
+        let normB = 0;
+        for (let i = 0; i < a.length; i++) {
+          dotProduct += a[i] * b[i];
+          normA += a[i] * a[i];
+          normB += b[i] * b[i];
+        }
+        if (normA === 0 || normB === 0) {
+          return 0;
+        }
+        return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
+      }
+      /**
+      * Perform similarity search across documents
+      * Returns topK most similar documents sorted by score descending
+      */
+      async similaritySearch(query, documents, topK = 5, model = "locusai/all-minilm-l6-v2") {
+        if (documents.length === 0) {
+          return [];
+        }
+        if (topK <= 0) {
+          return [];
+        }
+        const queryEmbedding = await this.generateEmbedding(query, model);
+        const results = [];
+        for (const doc of documents) {
+          const docEmbedding = await this.generateEmbedding(doc.text, model);
+          const score = this.cosineSimilarity(queryEmbedding, docEmbedding);
+          results.push({
+            doc,
+            score
+          });
+        }
+        results.sort((a, b) => b.score - a.score);
+        const topResults = results.slice(0, Math.min(topK, results.length));
+        return topResults.map((r) => ({
+          id: r.doc.id,
+          text: r.doc.text,
+          score: r.score
+        }));
+      }
+    };
+    EmbeddingHelper = _ts_decorate([
+      Injectable(),
+      _ts_metadata("design:type", Function),
+      _ts_metadata("design:paramtypes", [
+        String
+      ])
+    ], EmbeddingHelper);
+    generateEmbedding = /* @__PURE__ */ __name((...args) => new EmbeddingHelper().generateEmbedding(...args), "generateEmbedding");
+    cosineSimilarity = /* @__PURE__ */ __name((...args) => new EmbeddingHelper().cosineSimilarity(...args), "cosineSimilarity");
+    similaritySearch = /* @__PURE__ */ __name((...args) => new EmbeddingHelper().similaritySearch(...args), "similaritySearch");
+  }
+});
+
+export {
+  EmbeddingHelper,
+  generateEmbedding,
+  cosineSimilarity,
+  similaritySearch,
+  init_embedding
+};

package/dist/chunk-D7ADMHK2.js

@@ -0,0 +1,36 @@
+import { fileURLToPath as __synFup } from "url";import { dirname as __synDn } from "path";const __filename = __synFup(import.meta.url);const __dirname = __synDn(__filename);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+export {
+  __name,
+  __require,
+  __esm,
+  __export,
+  __toCommonJS
+};

package/dist/chunk-DXUYWRO7.js

@@ -0,0 +1,23 @@
+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/constants/coordinator.ts
+var OFFICIAL_COORDINATOR_URL = "https://api.synapseia.network";
+var OFFICIAL_COORDINATOR_WS_URL = "https://ws.synapseia.network";
+function getCoordinatorUrl() {
+  const v = process.env.COORDINATOR_URL?.trim();
+  return v && v.length > 0 ? v : OFFICIAL_COORDINATOR_URL;
+}
+__name(getCoordinatorUrl, "getCoordinatorUrl");
+function getCoordinatorWsUrl() {
+  const v = process.env.COORDINATOR_WS_URL?.trim();
+  return v && v.length > 0 ? v : OFFICIAL_COORDINATOR_WS_URL;
+}
+__name(getCoordinatorWsUrl, "getCoordinatorWsUrl");
+
+export {
+  getCoordinatorUrl,
+  getCoordinatorWsUrl
+};

package/dist/chunk-F5UDK56Z.js

@@ -0,0 +1,289 @@
+import { fileURLToPath as __synFup } from "url";import { dirname as __synDn } from "path";const __filename = __synFup(import.meta.url);const __dirname = __synDn(__filename);
+import {
+  priceUsdFromEnv
+} from "./chunk-NEHR6XY7.js";
+import {
+  beginChatInference,
+  endChatInference
+} from "./chunk-5ZAJBIAV.js";
+import {
+  init_logger,
+  logger_default
+} from "./chunk-V2L5SXTL.js";
+import {
+  __name
+} from "./chunk-D7ADMHK2.js";
+
+// src/modules/inference/inference-server.ts
+init_logger();
+import { Injectable } from "@nestjs/common";
+import * as http from "http";
+import * as crypto from "crypto";
+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 serverStartTime;
+function parseBody(req) {
+  return new Promise((resolve, reject) => {
+    let body = "";
+    req.on("data", (chunk) => {
+      body += chunk.toString();
+    });
+    req.on("end", () => {
+      try {
+        resolve(body ? JSON.parse(body) : {});
+      } catch (e) {
+        reject(e);
+      }
+    });
+    req.on("error", reject);
+  });
+}
+__name(parseBody, "parseBody");
+async function forwardToOllama(request) {
+  const ollamaRequest = {
+    model: request.model,
+    messages: request.messages,
+    stream: false
+  };
+  if (request.temperature !== void 0 || request.max_tokens !== void 0) {
+    ollamaRequest.options = {};
+    if (request.temperature !== void 0) {
+      ollamaRequest.options.temperature = request.temperature;
+    }
+    if (request.max_tokens !== void 0) {
+      ollamaRequest.options.num_predict = request.max_tokens;
+    }
+  }
+  const ollamaResponse = await fetch("http://localhost:11434/api/chat", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(ollamaRequest)
+  });
+  if (!ollamaResponse.ok) {
+    throw new Error(`Ollama API error: ${ollamaResponse.status} ${ollamaResponse.statusText}`);
+  }
+  return ollamaResponse.json();
+}
+__name(forwardToOllama, "forwardToOllama");
+function transformToOpenAI(ollamaResponse, model) {
+  return {
+    id: `chatcmpl-${crypto.randomUUID()}`,
+    object: "chat.completion",
+    created: Math.floor(Date.now() / 1e3),
+    model,
+    choices: [
+      {
+        index: 0,
+        message: {
+          role: ollamaResponse.message.role,
+          content: ollamaResponse.message.content
+        },
+        finish_reason: "stop"
+      }
+    ]
+  };
+}
+__name(transformToOpenAI, "transformToOpenAI");
+async function notifyCoordinatorInferenceRequest(coordinatorUrl, peerId) {
+  try {
+    await fetch(`${coordinatorUrl}/peers/${encodeURIComponent(peerId)}/inference-request`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+  } catch {
+  }
+}
+__name(notifyCoordinatorInferenceRequest, "notifyCoordinatorInferenceRequest");
+async function handleChatCompletions(req, res, peerId, coordinatorUrl) {
+  try {
+    const body = await parseBody(req);
+    if (!body.model || !body.messages || !Array.isArray(body.messages) || body.messages.length === 0) {
+      res.writeHead(400, {
+        "Content-Type": "application/json"
+      });
+      res.end(JSON.stringify({
+        error: {
+          message: "Invalid request: model and messages are required",
+          type: "invalid_request_error"
+        }
+      }));
+      return;
+    }
+    beginChatInference();
+    let ollamaResponse;
+    try {
+      ollamaResponse = await forwardToOllama(body);
+    } finally {
+      endChatInference();
+    }
+    const openaiResponse = transformToOpenAI(ollamaResponse, body.model);
+    res.writeHead(200, {
+      "Content-Type": "application/json"
+    });
+    res.end(JSON.stringify(openaiResponse));
+    if (coordinatorUrl) {
+      void notifyCoordinatorInferenceRequest(coordinatorUrl, peerId);
+    }
+  } catch (error) {
+    res.writeHead(500, {
+      "Content-Type": "application/json"
+    });
+    res.end(JSON.stringify({
+      error: {
+        message: error.message || "Internal server error",
+        type: "server_error"
+      }
+    }));
+  }
+}
+__name(handleChatCompletions, "handleChatCompletions");
+async function handleState(req, res, config) {
+  const uptime = process.uptime();
+  res.writeHead(200, {
+    "Content-Type": "application/json"
+  });
+  res.end(JSON.stringify({
+    peerId: config.peerId,
+    hardwareClass: config.hardwareClass,
+    models: config.models,
+    uptime: Math.floor(uptime)
+  }));
+}
+__name(handleState, "handleState");
+async function handleHealth(req, res) {
+  const uptime = process.uptime();
+  res.writeHead(200, {
+    "Content-Type": "application/json"
+  });
+  res.end(JSON.stringify({
+    status: "ok",
+    uptime: Math.floor(uptime)
+  }));
+}
+__name(handleHealth, "handleHealth");
+async function handleQuote(req, res) {
+  try {
+    const body = await parseBody(req);
+    const query = typeof body?.query === "string" ? body.query : "";
+    const priceUsd = priceUsdFromEnv(query);
+    res.writeHead(200, {
+      "Content-Type": "application/json"
+    });
+    res.end(JSON.stringify({
+      priceUsd
+    }));
+  } catch {
+    res.writeHead(200, {
+      "Content-Type": "application/json"
+    });
+    res.end(JSON.stringify({
+      priceUsd: priceUsdFromEnv("")
+    }));
+  }
+}
+__name(handleQuote, "handleQuote");
+function handleNotFound(req, res) {
+  res.writeHead(404, {
+    "Content-Type": "application/json"
+  });
+  res.end(JSON.stringify({
+    error: {
+      message: "Not found",
+      type: "not_found_error"
+    }
+  }));
+}
+__name(handleNotFound, "handleNotFound");
+function startInferenceServer(config) {
+  serverStartTime = Date.now();
+  const port = config.port !== void 0 && config.port !== null ? config.port : 8080;
+  const server = http.createServer(async (req, res) => {
+    const { applyLocalCors } = await import("./local-cors-J6RWNMMD.js");
+    if (applyLocalCors(req, res)) return;
+    const url = req.url || "";
+    try {
+      if (req.method === "POST" && url === "/v1/chat/completions") {
+        await handleChatCompletions(req, res, config.peerId, config.coordinatorUrl);
+      } else if (req.method === "POST" && url === "/inference/quote") {
+        await handleQuote(req, res);
+      } else if (req.method === "GET" && url === "/api/v1/state") {
+        await handleState(req, res, config);
+      } else if (req.method === "GET" && url === "/health") {
+        await handleHealth(req, res);
+      } else {
+        handleNotFound(req, res);
+      }
+    } catch (error) {
+      logger_default.error(`[InferenceServer] request error: ${error.message}`);
+      res.writeHead(500, {
+        "Content-Type": "application/json"
+      });
+      res.end(JSON.stringify({
+        error: {
+          message: "Internal server error",
+          type: "server_error"
+        }
+      }));
+    }
+  });
+  server.listen(port, () => {
+    logger_default.log(`[InferenceServer] listening on port ${port} (POST /v1/chat/completions, POST /inference/quote, GET /api/v1/state, GET /health)`);
+  });
+  return {
+    server,
+    close: /* @__PURE__ */ __name(() => {
+      server.close();
+      logger_default.log("[InferenceServer] closed");
+    }, "close")
+  };
+}
+__name(startInferenceServer, "startInferenceServer");
+var InferenceServerHelper = class {
+  static {
+    __name(this, "InferenceServerHelper");
+  }
+  parseBody(req) {
+    return parseBody(req);
+  }
+  forwardToOllama(request) {
+    return forwardToOllama(request);
+  }
+  transformToOpenAI(ollamaResponse, model) {
+    return transformToOpenAI(ollamaResponse, model);
+  }
+  handleChatCompletions(req, res, peerId, coordinatorUrl) {
+    return handleChatCompletions(req, res, peerId, coordinatorUrl);
+  }
+  handleState(req, res, config) {
+    return handleState(req, res, config);
+  }
+  handleHealth(req, res) {
+    return handleHealth(req, res);
+  }
+  startInferenceServer(config) {
+    return startInferenceServer(config);
+  }
+};
+InferenceServerHelper = _ts_decorate([
+  Injectable()
+], InferenceServerHelper);
+
+export {
+  parseBody,
+  forwardToOllama,
+  transformToOpenAI,
+  handleChatCompletions,
+  handleState,
+  handleHealth,
+  startInferenceServer,
+  InferenceServerHelper
+};

package/dist/chunk-NEHR6XY7.js

@@ -0,0 +1,111 @@
+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/QueryCostCalculator.ts
+var DEFAULT_MIN = 0.1;
+var DEFAULT_MAX = 1;
+var BIOMEDICAL_TERMS = [
+  "als",
+  "amyotrophic",
+  "alzheimer",
+  "parkinson",
+  "huntington",
+  "ms",
+  "multiple sclerosis",
+  "oncology",
+  "tumor",
+  "cancer",
+  "carcinoma",
+  "leukemia",
+  "lymphoma",
+  "glioma",
+  "cardiovascular",
+  "hypertension",
+  "diabetes",
+  "autoimmune",
+  "c9orf72",
+  "sod1",
+  "tardbp",
+  "fus",
+  "apoe",
+  "brca",
+  "tp53",
+  "kras",
+  "mrna",
+  "rna",
+  "dna",
+  "protein",
+  "enzyme",
+  "receptor",
+  "mutation",
+  "gene",
+  "genotype",
+  "phenotype",
+  "biomarker",
+  "pathway",
+  "mitochondri",
+  "microglia",
+  "riluzole",
+  "edaravone",
+  "pembrolizumab",
+  "inhibitor",
+  "antagonist",
+  "agonist",
+  "rna-seq",
+  "crispr",
+  "immunotherapy",
+  "chemotherapy",
+  "randomized",
+  "placebo",
+  "double-blind",
+  "meta-analysis",
+  "systematic review",
+  "clinical trial",
+  "phase ii",
+  "phase iii",
+  "in vitro",
+  "in vivo",
+  "mesh",
+  "rxnorm",
+  "hgnc",
+  "umls",
+  "doi",
+  "pubmed"
+];
+function computeQueryPriceUsd(query, config) {
+  const min = Number.isFinite(config.minPriceUsd) ? config.minPriceUsd : DEFAULT_MIN;
+  const max = Number.isFinite(config.maxPriceUsd) ? config.maxPriceUsd : DEFAULT_MAX;
+  if (max <= min) return min;
+  const text = (query ?? "").trim();
+  if (text.length === 0) return min;
+  const lower = text.toLowerCase();
+  const words = text.split(/\s+/).filter(Boolean).length;
+  const lengthScore = Math.min(words / 20, 1);
+  let techTerms = 0;
+  for (const term of BIOMEDICAL_TERMS) {
+    if (lower.includes(term)) techTerms++;
+  }
+  const techScore = Math.min(techTerms / 5, 1);
+  const hasCodeBlock = /```|\bcode\b|\bscript\b|\bsql\b|\bjson\b/.test(lower) ? 0.3 : 0;
+  const hasCitation = /\bcit(e|ation)\b|\breference(s)?\b|\bsource(s)?\b|\bdoi\b/.test(lower) ? 0.3 : 0;
+  const raw = lengthScore + techScore + hasCodeBlock + hasCitation;
+  const complexity = Math.min(raw / 2.6, 1);
+  return Number((min + (max - min) * complexity).toFixed(6));
+}
+__name(computeQueryPriceUsd, "computeQueryPriceUsd");
+function priceUsdFromEnv(query) {
+  const minPriceUsd = parseFloat(process.env.QUERY_MIN_PRICE ?? String(DEFAULT_MIN));
+  const maxPriceUsd = parseFloat(process.env.QUERY_MAX_PRICE ?? String(DEFAULT_MAX));
+  return computeQueryPriceUsd(query, {
+    minPriceUsd,
+    maxPriceUsd
+  });
+}
+__name(priceUsdFromEnv, "priceUsdFromEnv");
+
+export {
+  computeQueryPriceUsd,
+  priceUsdFromEnv
+};