@tradejs/infra 3.1.28-beta.258 → 3.1.29-beta.259

package/dist/jev.d.mts

@@ -0,0 +1,16 @@
+import { JevProviderConfig, JevResponse } from '@tradejs/types';
+
+declare const jevStableJson: (value: unknown) => string;
+declare const jevHash: (value: unknown) => string;
+declare const jevFileHash: (contents: string) => string;
+/** Writes once. Concurrent callers keep the first complete record. */
+declare const writeJevArtifact: (file: string, value: unknown) => Promise<void>;
+declare const readJevArtifact: <T>(file: string) => Promise<T | null>;
+declare const requestJev: (provider: JevProviderConfig, apiKey: string, state: unknown, questions: unknown, options?: {
+    fetch?: typeof fetch;
+    timeoutMs?: number;
+    retries?: number;
+}) => Promise<JevResponse>;
+declare const validateJevResponse: (body: unknown, expected: string[]) => JevResponse;
+
+export { jevFileHash, jevHash, jevStableJson, readJevArtifact, requestJev, validateJevResponse, writeJevArtifact };

package/dist/jev.d.ts

@@ -0,0 +1,16 @@
+import { JevProviderConfig, JevResponse } from '@tradejs/types';
+
+declare const jevStableJson: (value: unknown) => string;
+declare const jevHash: (value: unknown) => string;
+declare const jevFileHash: (contents: string) => string;
+/** Writes once. Concurrent callers keep the first complete record. */
+declare const writeJevArtifact: (file: string, value: unknown) => Promise<void>;
+declare const readJevArtifact: <T>(file: string) => Promise<T | null>;
+declare const requestJev: (provider: JevProviderConfig, apiKey: string, state: unknown, questions: unknown, options?: {
+    fetch?: typeof fetch;
+    timeoutMs?: number;
+    retries?: number;
+}) => Promise<JevResponse>;
+declare const validateJevResponse: (body: unknown, expected: string[]) => JevResponse;
+
+export { jevFileHash, jevHash, jevStableJson, readJevArtifact, requestJev, validateJevResponse, writeJevArtifact };

package/dist/jev.js

@@ -0,0 +1,184 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/jev.ts
+var jev_exports = {};
+__export(jev_exports, {
+  jevFileHash: () => jevFileHash,
+  jevHash: () => jevHash,
+  jevStableJson: () => jevStableJson,
+  readJevArtifact: () => readJevArtifact,
+  requestJev: () => requestJev,
+  validateJevResponse: () => validateJevResponse,
+  writeJevArtifact: () => writeJevArtifact
+});
+module.exports = __toCommonJS(jev_exports);
+var import_node_crypto = require("crypto");
+var import_promises = __toESM(require("fs/promises"));
+var import_node_path = __toESM(require("path"));
+var jevStableJson = (value) => {
+  if (Array.isArray(value)) return `[${value.map(jevStableJson).join(",")}]`;
+  if (value && typeof value === "object")
+    return `{${Object.entries(value).filter(([, v]) => v !== void 0).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => `${JSON.stringify(k)}:${jevStableJson(v)}`).join(",")}}`;
+  return JSON.stringify(value) ?? "null";
+};
+var jevHash = (value) => (0, import_node_crypto.createHash)("sha256").update(jevStableJson(value)).digest("hex");
+var jevFileHash = (contents) => (0, import_node_crypto.createHash)("sha256").update(contents).digest("hex");
+var writeJevArtifact = async (file, value) => {
+  await import_promises.default.mkdir(import_node_path.default.dirname(file), { recursive: true });
+  const temp = `${file}.${(0, import_node_crypto.randomUUID)()}.tmp`;
+  await import_promises.default.writeFile(
+    temp,
+    JSON.stringify({ checksum: jevHash(value), value }),
+    { mode: 384, flag: "wx" }
+  );
+  try {
+    await import_promises.default.link(temp, file);
+  } catch (error) {
+    if (error.code !== "EEXIST") throw error;
+  } finally {
+    await import_promises.default.unlink(temp);
+  }
+};
+var readJevArtifact = async (file) => {
+  let contents;
+  try {
+    contents = await import_promises.default.readFile(file, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  }
+  const envelope = JSON.parse(contents);
+  if (!envelope || envelope.checksum !== jevHash(envelope.value))
+    throw new Error("Jev artifact checksum mismatch");
+  return envelope.value;
+};
+var requestJev = async (provider, apiKey, state, questions, options = {}) => {
+  const fetcher = options.fetch ?? fetch;
+  const timeoutMs = options.timeoutMs ?? 3e4;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    for (let attempt = 0; ; attempt += 1) {
+      let response;
+      try {
+        response = await fetcher(provider.endpoint, {
+          method: "POST",
+          redirect: "error",
+          signal: controller.signal,
+          headers: {
+            Authorization: `Bearer ${apiKey}`,
+            "Content-Type": "application/json",
+            "HTTP-Referer": "https://tradejs.dev",
+            "X-Title": "TradeJS Jev"
+          },
+          body: JSON.stringify({ model: provider.model, state, questions })
+        });
+      } catch {
+        throw new Error(
+          controller.signal.aborted ? "Jev request timed out" : "Jev provider connection failed"
+        );
+      }
+      if (!response.ok) {
+        if ((response.status === 429 || response.status >= 500) && attempt < (options.retries ?? 2) && !controller.signal.aborted) {
+          const retryAfter = response.headers.get("retry-after");
+          const seconds = Number(retryAfter);
+          const delay = retryAfter && !Number.isFinite(seconds) ? Date.parse(retryAfter) - Date.now() : (seconds || 0.25 * 2 ** attempt) * 1e3;
+          if (delay >= timeoutMs)
+            throw new Error("Jev rate limit exceeds request deadline");
+          await new Promise((resolve, reject) => {
+            const onAbort = () => {
+              clearTimeout(wait);
+              reject(new Error("Jev request timed out"));
+            };
+            const wait = setTimeout(
+              () => {
+                controller.signal.removeEventListener("abort", onAbort);
+                resolve();
+              },
+              Math.max(0, delay)
+            );
+            controller.signal.addEventListener("abort", onAbort, {
+              once: true
+            });
+          });
+          continue;
+        }
+        throw new Error(`Jev provider HTTP ${response.status}`);
+      }
+      let body;
+      try {
+        body = await response.json();
+      } catch {
+        throw new Error("Jev provider returned invalid JSON");
+      }
+      return validateJevResponse(body, Object.keys(questions));
+    }
+  } finally {
+    clearTimeout(timer);
+  }
+};
+var validateJevResponse = (body, expected) => {
+  const result = body;
+  if (!result || typeof result.model !== "string" || !result.model || !result.answers)
+    throw new Error("Invalid Jev response");
+  if (!expected.length || expected.length > 4 || Object.keys(result.answers).sort().join(",") !== [...expected].sort().join(","))
+    throw new Error("Invalid Jev answer set");
+  for (const key of expected) {
+    const answer = result.answers[key];
+    if (!answer || answer.type !== "score" || !Number.isFinite(answer.score) || answer.score < 0 || answer.score > 4 || !Number.isFinite(answer.confidence) || answer.confidence < 0 || answer.confidence > 1)
+      throw new Error(`Invalid Jev ${key} answer`);
+    const probabilities = answer.probabilities;
+    if (!probabilities || Object.keys(probabilities).length !== 5 || [0, 1, 2, 3, 4].some(
+      (level) => !Number.isFinite(probabilities[level]) || probabilities[level] < 0 || probabilities[level] > 1
+    ))
+      throw new Error(`Invalid Jev ${key} probabilities`);
+    const roundingHalfUnit = 5e-3;
+    const epsilon = 1e-9;
+    if (Math.abs(Object.values(probabilities).reduce((a, b) => a + b, 0) - 1) > 5 * roundingHalfUnit + epsilon)
+      throw new Error("Jev probabilities must sum to one");
+    const mean = [0, 1, 2, 3, 4].reduce(
+      (sum, level) => sum + level * probabilities[level],
+      0
+    );
+    if (Math.abs(mean - answer.score) > (0 + 1 + 2 + 3 + 4 + 1) * roundingHalfUnit + epsilon)
+      throw new Error("Jev score disagrees with probabilities");
+  }
+  return result;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  jevFileHash,
+  jevHash,
+  jevStableJson,
+  readJevArtifact,
+  requestJev,
+  validateJevResponse,
+  writeJevArtifact
+});

package/dist/jev.mjs

@@ -0,0 +1,143 @@
+// src/jev.ts
+import { createHash, randomUUID } from "crypto";
+import fs from "fs/promises";
+import path from "path";
+var jevStableJson = (value) => {
+  if (Array.isArray(value)) return `[${value.map(jevStableJson).join(",")}]`;
+  if (value && typeof value === "object")
+    return `{${Object.entries(value).filter(([, v]) => v !== void 0).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => `${JSON.stringify(k)}:${jevStableJson(v)}`).join(",")}}`;
+  return JSON.stringify(value) ?? "null";
+};
+var jevHash = (value) => createHash("sha256").update(jevStableJson(value)).digest("hex");
+var jevFileHash = (contents) => createHash("sha256").update(contents).digest("hex");
+var writeJevArtifact = async (file, value) => {
+  await fs.mkdir(path.dirname(file), { recursive: true });
+  const temp = `${file}.${randomUUID()}.tmp`;
+  await fs.writeFile(
+    temp,
+    JSON.stringify({ checksum: jevHash(value), value }),
+    { mode: 384, flag: "wx" }
+  );
+  try {
+    await fs.link(temp, file);
+  } catch (error) {
+    if (error.code !== "EEXIST") throw error;
+  } finally {
+    await fs.unlink(temp);
+  }
+};
+var readJevArtifact = async (file) => {
+  let contents;
+  try {
+    contents = await fs.readFile(file, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  }
+  const envelope = JSON.parse(contents);
+  if (!envelope || envelope.checksum !== jevHash(envelope.value))
+    throw new Error("Jev artifact checksum mismatch");
+  return envelope.value;
+};
+var requestJev = async (provider, apiKey, state, questions, options = {}) => {
+  const fetcher = options.fetch ?? fetch;
+  const timeoutMs = options.timeoutMs ?? 3e4;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    for (let attempt = 0; ; attempt += 1) {
+      let response;
+      try {
+        response = await fetcher(provider.endpoint, {
+          method: "POST",
+          redirect: "error",
+          signal: controller.signal,
+          headers: {
+            Authorization: `Bearer ${apiKey}`,
+            "Content-Type": "application/json",
+            "HTTP-Referer": "https://tradejs.dev",
+            "X-Title": "TradeJS Jev"
+          },
+          body: JSON.stringify({ model: provider.model, state, questions })
+        });
+      } catch {
+        throw new Error(
+          controller.signal.aborted ? "Jev request timed out" : "Jev provider connection failed"
+        );
+      }
+      if (!response.ok) {
+        if ((response.status === 429 || response.status >= 500) && attempt < (options.retries ?? 2) && !controller.signal.aborted) {
+          const retryAfter = response.headers.get("retry-after");
+          const seconds = Number(retryAfter);
+          const delay = retryAfter && !Number.isFinite(seconds) ? Date.parse(retryAfter) - Date.now() : (seconds || 0.25 * 2 ** attempt) * 1e3;
+          if (delay >= timeoutMs)
+            throw new Error("Jev rate limit exceeds request deadline");
+          await new Promise((resolve, reject) => {
+            const onAbort = () => {
+              clearTimeout(wait);
+              reject(new Error("Jev request timed out"));
+            };
+            const wait = setTimeout(
+              () => {
+                controller.signal.removeEventListener("abort", onAbort);
+                resolve();
+              },
+              Math.max(0, delay)
+            );
+            controller.signal.addEventListener("abort", onAbort, {
+              once: true
+            });
+          });
+          continue;
+        }
+        throw new Error(`Jev provider HTTP ${response.status}`);
+      }
+      let body;
+      try {
+        body = await response.json();
+      } catch {
+        throw new Error("Jev provider returned invalid JSON");
+      }
+      return validateJevResponse(body, Object.keys(questions));
+    }
+  } finally {
+    clearTimeout(timer);
+  }
+};
+var validateJevResponse = (body, expected) => {
+  const result = body;
+  if (!result || typeof result.model !== "string" || !result.model || !result.answers)
+    throw new Error("Invalid Jev response");
+  if (!expected.length || expected.length > 4 || Object.keys(result.answers).sort().join(",") !== [...expected].sort().join(","))
+    throw new Error("Invalid Jev answer set");
+  for (const key of expected) {
+    const answer = result.answers[key];
+    if (!answer || answer.type !== "score" || !Number.isFinite(answer.score) || answer.score < 0 || answer.score > 4 || !Number.isFinite(answer.confidence) || answer.confidence < 0 || answer.confidence > 1)
+      throw new Error(`Invalid Jev ${key} answer`);
+    const probabilities = answer.probabilities;
+    if (!probabilities || Object.keys(probabilities).length !== 5 || [0, 1, 2, 3, 4].some(
+      (level) => !Number.isFinite(probabilities[level]) || probabilities[level] < 0 || probabilities[level] > 1
+    ))
+      throw new Error(`Invalid Jev ${key} probabilities`);
+    const roundingHalfUnit = 5e-3;
+    const epsilon = 1e-9;
+    if (Math.abs(Object.values(probabilities).reduce((a, b) => a + b, 0) - 1) > 5 * roundingHalfUnit + epsilon)
+      throw new Error("Jev probabilities must sum to one");
+    const mean = [0, 1, 2, 3, 4].reduce(
+      (sum, level) => sum + level * probabilities[level],
+      0
+    );
+    if (Math.abs(mean - answer.score) > (0 + 1 + 2 + 3 + 4 + 1) * roundingHalfUnit + epsilon)
+      throw new Error("Jev score disagrees with probabilities");
+  }
+  return result;
+};
+export {
+  jevFileHash,
+  jevHash,
+  jevStableJson,
+  readJevArtifact,
+  requestJev,
+  validateJevResponse,
+  writeJevArtifact
+};

package/dist/userSettings.d.mts

@@ -3,6 +3,9 @@ interface UserRecord extends Record<string, unknown> {
     passwordHash?: string;
     COINALYZE_API_KEY?: string;
     COINMARKETCAP_API_KEY?: string;
+    JEV_API_KEY?: string;
+    JEV_API_ENDPOINT?: string;
+    JEV_MODEL?: string;
     AI_API_KEY?: string;
     AI_API_ENDPOINT?: string;
     AI_MODEL?: string;
@@ -15,6 +18,9 @@ interface UserSettings {
     userName: string;
     COINALYZE_API_KEY: string;
     COINMARKETCAP_API_KEY: string;
+    JEV_API_KEY?: string;
+    JEV_API_ENDPOINT?: string;
+    JEV_MODEL?: string;
     AI_API_KEY: string;
     AI_API_ENDPOINT: string;
     AI_MODEL: string;

package/dist/userSettings.d.ts

@@ -3,6 +3,9 @@ interface UserRecord extends Record<string, unknown> {
     passwordHash?: string;
     COINALYZE_API_KEY?: string;
     COINMARKETCAP_API_KEY?: string;
+    JEV_API_KEY?: string;
+    JEV_API_ENDPOINT?: string;
+    JEV_MODEL?: string;
     AI_API_KEY?: string;
     AI_API_ENDPOINT?: string;
     AI_MODEL?: string;
@@ -15,6 +18,9 @@ interface UserSettings {
     userName: string;
     COINALYZE_API_KEY: string;
     COINMARKETCAP_API_KEY: string;
+    JEV_API_KEY?: string;
+    JEV_API_ENDPOINT?: string;
+    JEV_MODEL?: string;
     AI_API_KEY: string;
     AI_API_ENDPOINT: string;
     AI_MODEL: string;

package/dist/userSettings.js

@@ -323,6 +323,9 @@ var getUserSettings = async (userName) => {
     userName,
     COINALYZE_API_KEY: readUserString(record, "COINALYZE_API_KEY"),
     COINMARKETCAP_API_KEY: readUserString(record, "COINMARKETCAP_API_KEY"),
+    JEV_API_KEY: readUserString(record, "JEV_API_KEY"),
+    JEV_API_ENDPOINT: readUserString(record, "JEV_API_ENDPOINT"),
+    JEV_MODEL: readUserString(record, "JEV_MODEL"),
     AI_API_KEY: readUserString(record, "AI_API_KEY"),
     AI_API_ENDPOINT: readUserString(record, "AI_API_ENDPOINT"),
     AI_MODEL: readUserString(record, "AI_MODEL"),

package/dist/userSettings.mjs

@@ -20,6 +20,9 @@ var getUserSettings = async (userName) => {
     userName,
     COINALYZE_API_KEY: readUserString(record, "COINALYZE_API_KEY"),
     COINMARKETCAP_API_KEY: readUserString(record, "COINMARKETCAP_API_KEY"),
+    JEV_API_KEY: readUserString(record, "JEV_API_KEY"),
+    JEV_API_ENDPOINT: readUserString(record, "JEV_API_ENDPOINT"),
+    JEV_MODEL: readUserString(record, "JEV_MODEL"),
     AI_API_KEY: readUserString(record, "AI_API_KEY"),
     AI_API_ENDPOINT: readUserString(record, "AI_API_ENDPOINT"),
     AI_MODEL: readUserString(record, "AI_MODEL"),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tradejs/infra",
-  "version": "3.1.28-beta.258",
+  "version": "3.1.29-beta.259",
   "description": "MIT-licensed server infrastructure adapters for TradeJS: Redis, Timescale, ML, logging, and IO.",
   "keywords": [
     "tradejs",
@@ -130,12 +130,17 @@
       "types": "./dist/tradingAccounts.d.ts",
       "import": "./dist/tradingAccounts.mjs",
       "require": "./dist/tradingAccounts.js"
+    },
+    "./jev": {
+      "types": "./dist/jev.d.ts",
+      "import": "./dist/jev.mjs",
+      "require": "./dist/jev.js"
     }
   },
   "dependencies": {
     "@grpc/grpc-js": "^1.14.4",
     "@grpc/proto-loader": "^0.8.1",
-    "@tradejs/types": "^3.1.28-beta.258",
+    "@tradejs/types": "^3.1.29-beta.259",
     "chalk": "4.1.2",
     "date-fns": "^3.6.0",
     "ioredis": "5.11.1",