chainlesschain 0.66.0 → 0.81.0

package/src/lib/inference-network.js

@@ -404,4 +404,334 @@ export function getSchedulerStats(db) {
 export function _resetState() {
   _nodes.clear();
   _tasks.clear();
+  _maxConcurrentTasksPerNode = INFERENCE_DEFAULT_MAX_CONCURRENT_TASKS_PER_NODE;
+  _heartbeatTimeoutMs = INFERENCE_DEFAULT_HEARTBEAT_TIMEOUT_MS;
+}
+
+/* ──────────────────────────────────────────────────────────
+ *  V2 — Phase 67 surface (strictly additive)
+ * ────────────────────────────────────────────────────────── */
+
+export const NODE_STATUS_V2 = NODE_STATUS;
+export const TASK_STATUS_V2 = TASK_STATUS;
+export const PRIVACY_MODE_V2 = PRIVACY_MODE;
+
+export const INFERENCE_DEFAULT_MAX_CONCURRENT_TASKS_PER_NODE = 4;
+export const INFERENCE_DEFAULT_HEARTBEAT_TIMEOUT_MS = 90000;
+
+let _maxConcurrentTasksPerNode =
+  INFERENCE_DEFAULT_MAX_CONCURRENT_TASKS_PER_NODE;
+let _heartbeatTimeoutMs = INFERENCE_DEFAULT_HEARTBEAT_TIMEOUT_MS;
+
+const TASK_TRANSITIONS_V2 = new Map([
+  ["queued", new Set(["dispatched", "failed"])],
+  ["dispatched", new Set(["running", "failed"])],
+  ["running", new Set(["complete", "failed"])],
+]);
+const TASK_TERMINALS_V2 = new Set(["complete", "failed"]);
+
+export function setMaxConcurrentTasksPerNode(n) {
+  if (typeof n !== "number" || Number.isNaN(n) || n < 1) {
+    throw new Error("maxConcurrentTasksPerNode must be a positive integer");
+  }
+  _maxConcurrentTasksPerNode = Math.floor(n);
+}
+
+export function getMaxConcurrentTasksPerNode() {
+  return _maxConcurrentTasksPerNode;
+}
+
+export function setHeartbeatTimeoutMs(ms) {
+  if (typeof ms !== "number" || Number.isNaN(ms) || ms < 1) {
+    throw new Error("heartbeatTimeoutMs must be a positive integer");
+  }
+  _heartbeatTimeoutMs = Math.floor(ms);
+}
+
+export function getHeartbeatTimeoutMs() {
+  return _heartbeatTimeoutMs;
+}
+
+export function getActiveTasksPerNode(nodeId) {
+  if (!nodeId) return 0;
+  let count = 0;
+  for (const t of _tasks.values()) {
+    if (
+      t.assigned_node === nodeId &&
+      (t.status === "dispatched" || t.status === "running")
+    ) {
+      count += 1;
+    }
+  }
+  return count;
+}
+
+export function submitTaskV2(db, { model, input, privacyMode, priority } = {}) {
+  if (!model) throw new Error("model is required");
+  const mode = privacyMode || DEFAULT_CONFIG.defaultPrivacyMode;
+  if (!VALID_PRIVACY_MODES.has(mode)) {
+    throw new Error(`Invalid privacy mode: ${mode}`);
+  }
+  const prio = Math.min(Math.max(priority || 5, 1), DEFAULT_CONFIG.maxPriority);
+
+  const id = _id();
+  const now = _now();
+  const task = {
+    id,
+    model,
+    input: input || null,
+    output: null,
+    privacy_mode: mode,
+    priority: prio,
+    assigned_node: null,
+    status: "queued",
+    duration_ms: null,
+    created_at: now,
+    completed_at: null,
+    started_at: null,
+    error_message: null,
+  };
+
+  db.prepare(
+    `INSERT INTO inference_tasks (id, model, input, output, privacy_mode, priority,
+     assigned_node, status, duration_ms, created_at, completed_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+  ).run(
+    id,
+    model,
+    task.input,
+    null,
+    mode,
+    prio,
+    null,
+    "queued",
+    null,
+    now,
+    null,
+  );
+
+  _tasks.set(id, task);
+  return { ...task };
+}
+
+function _pickLeastLoadedOnline(privacyMode) {
+  let best = null;
+  let bestLoad = Infinity;
+  for (const n of _nodes.values()) {
+    if (n.status !== "online") continue;
+    const load = getActiveTasksPerNode(n.id);
+    if (load >= _maxConcurrentTasksPerNode) continue;
+    if (load < bestLoad) {
+      best = n;
+      bestLoad = load;
+    }
+  }
+  return best;
+}
+
+export function dispatchTaskV2(db, taskId, { nodeId } = {}) {
+  const t = _tasks.get(taskId);
+  if (!t) throw new Error(`Unknown task: ${taskId}`);
+  if (t.status !== "queued") {
+    throw new Error(
+      `Invalid transition: ${t.status} → dispatched (must be queued)`,
+    );
+  }
+
+  let target = null;
+  if (nodeId) {
+    target = _nodes.get(nodeId);
+    if (!target) throw new Error(`Unknown node: ${nodeId}`);
+    if (target.status !== "online") {
+      throw new Error(`Node ${nodeId} is not online (status=${target.status})`);
+    }
+    if (getActiveTasksPerNode(nodeId) >= _maxConcurrentTasksPerNode) {
+      throw new Error(`Max concurrent tasks reached for node ${nodeId}`);
+    }
+  } else {
+    target = _pickLeastLoadedOnline(t.privacy_mode);
+    if (!target) throw new Error("No eligible online nodes available");
+  }
+
+  t.status = "dispatched";
+  t.assigned_node = target.id;
+  target.task_count += 1;
+
+  db.prepare(
+    `UPDATE inference_tasks SET status = ?, assigned_node = ? WHERE id = ?`,
+  ).run("dispatched", target.id, taskId);
+  db.prepare("UPDATE inference_nodes SET task_count = ? WHERE id = ?").run(
+    target.task_count,
+    target.id,
+  );
+
+  return { ...t };
+}
+
+export function startTask(db, taskId) {
+  const t = _tasks.get(taskId);
+  if (!t) throw new Error(`Unknown task: ${taskId}`);
+  if (t.status !== "dispatched") {
+    throw new Error(
+      `Invalid transition: ${t.status} → running (must be dispatched)`,
+    );
+  }
+  t.status = "running";
+  t.started_at = _now();
+  db.prepare("UPDATE inference_tasks SET status = ? WHERE id = ?").run(
+    "running",
+    taskId,
+  );
+  return { ...t };
+}
+
+export function completeTaskV2(db, taskId, { output, durationMs } = {}) {
+  const t = _tasks.get(taskId);
+  if (!t) throw new Error(`Unknown task: ${taskId}`);
+  if (t.status !== "running") {
+    throw new Error(
+      `Invalid transition: ${t.status} → complete (must be running)`,
+    );
+  }
+  t.status = "complete";
+  t.output = output != null ? output : null;
+  t.completed_at = _now();
+  if (durationMs != null) {
+    t.duration_ms = durationMs;
+  } else if (t.started_at) {
+    t.duration_ms = t.completed_at - t.started_at;
+  } else {
+    t.duration_ms = t.completed_at - t.created_at;
+  }
+
+  db.prepare(
+    `UPDATE inference_tasks SET status = ?, output = ?, completed_at = ?,
+     duration_ms = ? WHERE id = ?`,
+  ).run("complete", t.output, t.completed_at, t.duration_ms, taskId);
+
+  return { ...t };
+}
+
+export function failTaskV2(db, taskId, { error } = {}) {
+  const t = _tasks.get(taskId);
+  if (!t) throw new Error(`Unknown task: ${taskId}`);
+  if (!TASK_TRANSITIONS_V2.get(t.status)?.has("failed")) {
+    throw new Error(`Invalid transition: ${t.status} → failed`);
+  }
+  t.status = "failed";
+  t.error_message = error || null;
+  t.output = error || null;
+  t.completed_at = _now();
+
+  db.prepare(
+    "UPDATE inference_tasks SET status = ?, output = ?, completed_at = ? WHERE id = ?",
+  ).run("failed", t.output, t.completed_at, taskId);
+
+  return { ...t };
+}
+
+export function setTaskStatus(db, taskId, newStatus, patch = {}) {
+  const t = _tasks.get(taskId);
+  if (!t) throw new Error(`Unknown task: ${taskId}`);
+  if (!Object.values(TASK_STATUS).includes(newStatus)) {
+    throw new Error(`Unknown status: ${newStatus}`);
+  }
+  const allowed = TASK_TRANSITIONS_V2.get(t.status);
+  if (!allowed || !allowed.has(newStatus)) {
+    throw new Error(`Invalid transition: ${t.status} → ${newStatus}`);
+  }
+
+  t.status = newStatus;
+  if (patch.output !== undefined) t.output = patch.output;
+  if (patch.errorMessage !== undefined) t.error_message = patch.errorMessage;
+  if (patch.durationMs !== undefined) t.duration_ms = patch.durationMs;
+  if (patch.startedAt !== undefined) t.started_at = patch.startedAt;
+  if (newStatus === "running" && !t.started_at) t.started_at = _now();
+  if (TASK_TERMINALS_V2.has(newStatus)) {
+    t.completed_at = t.completed_at || _now();
+  }
+
+  db.prepare(
+    `UPDATE inference_tasks SET status = ?, output = ?, completed_at = ?,
+     duration_ms = ? WHERE id = ?`,
+  ).run(newStatus, t.output, t.completed_at, t.duration_ms, taskId);
+
+  return { ...t };
+}
+
+export function autoMarkOfflineNodes(db) {
+  const cutoff = _now() - _heartbeatTimeoutMs;
+  const offlined = [];
+  for (const n of _nodes.values()) {
+    if (n.status === "offline") continue;
+    if (n.last_heartbeat < cutoff) {
+      n.status = "offline";
+      db.prepare("UPDATE inference_nodes SET status = ? WHERE id = ?").run(
+        "offline",
+        n.id,
+      );
+      offlined.push({ ...n });
+    }
+  }
+  return offlined;
+}
+
+export function findEligibleNodes({ capability, privacyMode } = {}) {
+  const _ = privacyMode; // reserved for future mode-aware routing
+  const out = [];
+  for (const n of _nodes.values()) {
+    if (n.status !== "online") continue;
+    if (getActiveTasksPerNode(n.id) >= _maxConcurrentTasksPerNode) continue;
+    if (capability) {
+      if (
+        !Array.isArray(n.capabilities) ||
+        !n.capabilities.includes(capability)
+      ) {
+        continue;
+      }
+    }
+    out.push({ ...n });
+  }
+  return out.sort(
+    (a, b) => getActiveTasksPerNode(a.id) - getActiveTasksPerNode(b.id),
+  );
+}
+
+export function getInferenceStatsV2() {
+  const nodesByStatus = {};
+  for (const s of Object.values(NODE_STATUS)) nodesByStatus[s] = 0;
+  const tasksByStatus = {};
+  for (const s of Object.values(TASK_STATUS)) tasksByStatus[s] = 0;
+  const tasksByPrivacyMode = {};
+  for (const m of Object.values(PRIVACY_MODE)) tasksByPrivacyMode[m] = 0;
+
+  const loadPerNode = {};
+  for (const n of _nodes.values()) {
+    nodesByStatus[n.status] = (nodesByStatus[n.status] || 0) + 1;
+    loadPerNode[n.id] = getActiveTasksPerNode(n.id);
+  }
+
+  let durSum = 0;
+  let durCount = 0;
+  for (const t of _tasks.values()) {
+    tasksByStatus[t.status] = (tasksByStatus[t.status] || 0) + 1;
+    tasksByPrivacyMode[t.privacy_mode] =
+      (tasksByPrivacyMode[t.privacy_mode] || 0) + 1;
+    if (t.status === "complete" && typeof t.duration_ms === "number") {
+      durSum += t.duration_ms;
+      durCount += 1;
+    }
+  }
+
+  return {
+    totalNodes: _nodes.size,
+    totalTasks: _tasks.size,
+    maxConcurrentTasksPerNode: _maxConcurrentTasksPerNode,
+    heartbeatTimeoutMs: _heartbeatTimeoutMs,
+    nodesByStatus,
+    tasksByStatus,
+    tasksByPrivacyMode,
+    loadPerNode,
+    avgDurationMs: durCount > 0 ? Math.round(durSum / durCount) : 0,
+  };
 }