@peopl-health/nexus 5.1.0-dev.469 → 6.0.0-dev.466

package/lib/clinical/models/turnTraceModel.js

@@ -44,17 +44,6 @@ turnTraceSchema.methods.addStep = function addStep(step) { this.steps.push({ ...
 turnTraceSchema.methods.setStatus = function setStatus(status, abort = null) { this.status = status; this.abort = abort; };
 turnTraceSchema.methods.setTimings = function setTimings(timings) { this.timings = { ...this.timings, ...timings }; };
 
-turnTraceSchema.methods.toDecision = function toDecision() {
-  const decision = this.safetyDecision || {};
-  const signals = this.signals || {};
-  return {
-    escalation_kind: decision.escalationKind || null,
-    outbound_purpose: signals.outboundPurpose || null,
-    branch_taken: signals.branchTaken || null,
-    red_flags_matched: decision.redFlagsMatched || [],
-  };
-};
-
 turnTraceSchema.methods.setPrompt = function setPrompt({ resolved, resolvedPresetId, resolvedPresetVersion }) {
   this.prompt = {
     resolved: resolved || null,

package/lib/clinical/services/fhirService.js

@@ -1,22 +1,24 @@
 const { load } = require('../config/fhirConfig');
-const { createProjectorRegistry } = require('../helpers/projectorHelper');
 
-const registry = createProjectorRegistry({
-  label: 'FHIR projector',
-  assemble: (items) => {
-    const entry = items
-      .flatMap(({ content }) => (content || []).flat())
-      .map((resource) => ({ resource }));
-    return { resourceType: 'Bundle', type: 'collection', entry };
-  },
-});
+const projectors = new Map();
+
+function registerProjector(name, fn) {
+  projectors.set(name, fn);
+}
 
 async function project(items) {
   await load();
-  return registry.project(items);
+  const entry = items
+    .flatMap(({ name, aggregate }) => {
+      const fn = projectors.get(name);
+      if (!fn) throw new Error(`no FHIR projector registered for '${name}'`);
+      return (fn(aggregate) || []).flat();
+    })
+    .map((resource) => ({ resource }));
+  return { resourceType: 'Bundle', type: 'collection', entry };
 }
 
 module.exports = {
-  registerProjector: registry.register,
+  registerProjector,
   project,
 };

package/lib/utils/jsonUtils.js

@@ -9,12 +9,6 @@ function jsonStringifyWithUnicodeEscapes(obj) {
   });
 }
 
-function isPlainObject(value) {
-  if (value === null || typeof value !== 'object') return false;
-  const proto = Object.getPrototypeOf(value);
-  return proto === Object.prototype || proto === null;
-}
-
 function safeParse(value, fallback = {}) {
   try {
     return JSON.parse(value || JSON.stringify(fallback));
@@ -23,31 +17,4 @@ function safeParse(value, fallback = {}) {
   }
 }
 
-function safeParseArray(value, fallback = null) {
-  const parsed = safeParse(value, fallback);
-  return Array.isArray(parsed) ? parsed : fallback;
-}
-
-function cleanForJson(value) {
-  if (value === null || value === undefined) return value;
-  if (value instanceof Date) return value.toISOString();
-  if (typeof value === 'object' && typeof value.toHexString === 'function') return value.toHexString();
-  if (Array.isArray(value)) return value.map(cleanForJson);
-  if (typeof value === 'object') {
-    const out = {};
-    for (const [key, val] of Object.entries(value)) {
-      if (key === '_id' || key === '__v') continue;
-      out[key] = cleanForJson(val);
-    }
-    return out;
-  }
-  return value;
-}
-
-module.exports = {
-  jsonStringifyWithUnicodeEscapes,
-  safeParse,
-  safeParseArray,
-  cleanForJson,
-  isPlainObject,
-};
+module.exports = { jsonStringifyWithUnicodeEscapes, safeParse };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peopl-health/nexus",
-  "version": "5.1.0-dev.469",
+  "version": "6.0.0-dev.466",
   "description": "Core messaging and assistant library for WhatsApp communication platforms",
   "keywords": [
     "whatsapp",

package/lib/clinical/config/divergenceConfig.js

@@ -1,58 +0,0 @@
-const { Config_ID } = require('../../config/airtableConfig');
-
-const { getRecordByFilter } = require('../../services/airtableService');
-
-const MapCache = require('../../utils/MapCache');
-const { safeParse, safeParseArray, isPlainObject } = require('../../utils/jsonUtils');
-
-const DIVERGENCE_CONFIG_TABLE = 'divergence';
-const CACHE_TTL = 5 * 60 * 1000;
-const CACHE_KEY = 'divergenceConfig';
-const COMPARATOR_TYPES = ['scalar', 'set'];
-const ORACLE_CONNECTION_DEFAULTS = { enabled: false, baseUrl: '', timeoutMs: null };
-
-const cache = new MapCache({ maxSize: 1, ttl: CACHE_TTL });
-
-async function load() {
-  const cached = cache.get(CACHE_KEY);
-  if (cached) return cached;
-
-  const records = await getRecordByFilter(Config_ID, DIVERGENCE_CONFIG_TABLE, 'TRUE()');
-  if (!records) throw new Error('divergence config could not be read from the Config base');
-  const byKey = Object.fromEntries(records.map((r) => [r.config, r.value]));
-
-  if (!byKey.FIELDS) throw new Error('divergence config missing from Config base: FIELDS');
-  const fields = safeParseArray(byKey.FIELDS);
-  if (!fields) throw new Error('divergence config FIELDS is not a JSON array');
-  if (!fields.length) throw new Error('divergence config FIELDS is empty; nothing would be compared');
-
-  const unknown = fields.filter(({ type }) => !COMPARATOR_TYPES.includes(type));
-  if (unknown.length) throw new Error(`divergence config FIELDS has unknown types: ${unknown.map(({ field, type }) => `${field}:${type}`).join(', ')}`);
-
-  const misplaced = fields.filter(({ type, emergencyKinds }) => emergencyKinds && type !== 'scalar');
-  if (misplaced.length) throw new Error(`divergence config emergencyKinds only applies to scalar fields: ${misplaced.map(({ field }) => field).join(', ')}`);
-
-  const parsedOracle = safeParse(byKey.ORACLE_CONNECTION, null);
-  if (byKey.ORACLE_CONNECTION && !isPlainObject(parsedOracle)) throw new Error('divergence config ORACLE_CONNECTION is not a JSON object');
-  const oracleConnection = { ...ORACLE_CONNECTION_DEFAULTS, ...(parsedOracle || {}) };
-  if (oracleConnection.enabled) {
-    oracleConnection.timeoutMs = Number(oracleConnection.timeoutMs);
-    if (!Number.isFinite(oracleConnection.timeoutMs) || oracleConnection.timeoutMs <= 0) throw new Error('divergence config ORACLE_CONNECTION.timeoutMs is not a positive number');
-  }
-
-  const config = { FIELDS: fields, ORACLE_CONNECTION: oracleConnection };
-  cache.set(CACHE_KEY, config);
-  return config;
-}
-
-function current() {
-  const cached = cache.get(CACHE_KEY);
-  if (!cached) throw new Error('divergence config not loaded; call load() first');
-  return cached;
-}
-
-module.exports = {
-  load,
-  getFields: () => current().FIELDS,
-  getOracleConnection: () => current().ORACLE_CONNECTION,
-};

package/lib/clinical/helpers/divergenceHelper.js

@@ -1,52 +0,0 @@
-const { isDeepStrictEqual } = require('node:util');
-
-const divergenceConfig = require('../config/divergenceConfig');
-
-const COMPARATORS = {
-  scalar: (expected, actual) => expected === actual,
-  set: (expected, actual) => isDeepStrictEqual(new Set(expected || []), new Set(actual || [])),
-};
-
-const OUTCOME_RULES = [
-  [({ deterministic }) => deterministic.divergences.some((d) => d.isEmergencyFlip), 'review'],
-  [({ stochastic }) => stochastic.verdict === 'fail', 'fail'],
-  [({ deterministic }) => !deterministic.hasPassed, 'diverged'],
-  [({ stochastic }) => stochastic.verdict === 'review', 'review'],
-];
-
-function deterministicDivergence(expected = {}, actual = {}, fields) {
-  const divergences = fields
-    .filter(({ field, type }) => {
-      const compare = COMPARATORS[type];
-      if (!compare) throw new Error(`unknown divergence field type '${type}'`);
-      return !compare(expected?.[field], actual?.[field]);
-    })
-    .map(({ field, emergencyKinds = [] }) => ({
-      field,
-      expected: expected?.[field],
-      actual: actual?.[field],
-      isEmergencyFlip: emergencyKinds.includes(expected?.[field]) || emergencyKinds.includes(actual?.[field]),
-    }));
-  return { divergences, hasPassed: divergences.length === 0 };
-}
-
-function stochasticDivergence() {
-  return { verdict: 'review', rationale: 'stochastic message grading not yet enabled', graded: false };
-}
-
-async function classify({ expected, actual, expectedMessage, actualMessage }) {
-  const deterministic = deterministicDivergence(expected, actual, divergenceConfig.getFields());
-  const stochastic = await stochasticDivergence(expectedMessage, actualMessage);
-  const result = OUTCOME_RULES.find(([applies]) => applies({ deterministic, stochastic }))?.[1] || 'pass';
-  return {
-    deterministic,
-    stochastic,
-    result,
-    isEmergencyReview: deterministic.divergences.some((d) => d.isEmergencyFlip),
-  };
-}
-
-module.exports = {
-  deterministicDivergence,
-  classify,
-};

package/lib/clinical/helpers/projectorHelper.js

@@ -1,18 +0,0 @@
-function createProjectorRegistry({ assemble, label = 'projector' }) {
-  const projectors = new Map();
-  return {
-    register: (name, fn) => projectors.set(name, fn),
-    project: (items) =>
-      assemble(
-        items.map(({ name, aggregate }) => {
-          const fn = projectors.get(name);
-          if (!fn) throw new Error(`no ${label} registered for '${name}'`);
-          return { name, content: fn(aggregate) };
-        }),
-      ),
-  };
-}
-
-module.exports = {
-  createProjectorRegistry,
-};

package/lib/clinical/helpers/seedHelper.js

@@ -1,62 +0,0 @@
-const { cleanForJson, isPlainObject } = require('../../utils/jsonUtils');
-
-const SEED_FORMATS = {
-  '.json': {
-    isValid: (c) => isPlainObject(c) && Object.values(c).every(isPlainObject),
-    hint: 'an object keyed by id whose values are plain objects',
-  },
-  '.jsonl': {
-    isValid: (c) => Array.isArray(c) && c.every(isPlainObject),
-    hint: 'a list of plain objects',
-  },
-};
-
-// clinical-agent file-store shapes:
-//   keyedFile → KeyedJSONFile (`{pk: doc}` written as `.json`)
-//   jsonlFile → JSONLFileStore (list-of-dicts written as `.jsonl`)
-function keyedFile(records, primaryKey) {
-  const out = {};
-  for (const record of records) {
-    const doc = cleanForJson(record);
-    const key = doc[primaryKey];
-    if (key === undefined || key === null || key === '') {
-      throw new Error(`keyed store record is missing primary key '${primaryKey}'`);
-    }
-    const skey = String(key);
-    if (Object.prototype.hasOwnProperty.call(out, skey)) {
-      throw new Error(`keyed store has duplicate primary key '${primaryKey}' value '${skey}'`);
-    }
-    out[skey] = doc;
-  }
-  return out;
-}
-
-function jsonlFile(records) {
-  return records.map(cleanForJson);
-}
-
-function validateSeed(seed) {
-  const basenames = new Set();
-  for (const [name, content] of Object.entries(seed)) {
-    const basename = name.split('/').pop();
-    if (!basename || basename === '.' || basename === '..') {
-      throw new Error(`invalid seed file name: '${name}'`);
-    }
-    if (basenames.has(basename)) {
-      throw new Error(`duplicate seed file basename: '${basename}'`);
-    }
-    basenames.add(basename);
-
-    const ext = Object.keys(SEED_FORMATS).find((extension) => basename.endsWith(extension));
-    const format = ext ? SEED_FORMATS[ext] : null;
-    if (!format) throw new Error(`seed file must end in .json or .jsonl: '${name}'`);
-    if (!format.isValid(content)) throw new Error(`'${name}' must be ${format.hint}`);
-  }
-  return seed;
-}
-
-module.exports = {
-  keyedFile,
-  jsonlFile,
-  validateSeed,
-};

package/lib/clinical/services/clinicalAgentService.js

@@ -1,18 +0,0 @@
-const axios = require('axios');
-
-async function runClinicalAgent(request, { baseUrl, apiKey, timeoutMs } = {}) {
-  if (!baseUrl) throw new Error('runClinicalAgent requires a baseUrl');
-  const res = await axios({
-    url: `${baseUrl}/api/oracle/turn`,
-    method: 'POST',
-    data: request,
-    timeout: timeoutMs,
-    headers: { 'content-type': 'application/json', 'x-api-key': apiKey },
-    validateStatus: () => true,
-  });
-  return { status: res.status, body: res.data ?? null };
-}
-
-module.exports = {
-  runClinicalAgent
-};

package/lib/clinical/services/divergenceService.js

@@ -1,58 +0,0 @@
-const runtimeConfig = require('../../config/runtimeConfig');
-const divergenceConfig = require('../config/divergenceConfig');
-
-const { runClinicalAgent } = require('./clinicalAgentService');
-
-const { classify } = require('../helpers/divergenceHelper');
-
-async function runDivergence({ request, connection, trace, outbound }) {
-  let post;
-  try {
-    post = await runClinicalAgent(request, connection);
-    if (post.status !== 200) {
-      return { ok: false, status: post.status, response: post.body };
-    }
-  } catch (error) {
-    return { ok: false, status: 503, response: { error: error.message } };
-  }
-  const expected = post.body?.run?.sessions?.[0]?.turns?.[0] || {};
-
-  const actual = trace.toDecision();
-  const outcome = await classify({
-    expected,
-    actual,
-    expectedMessage: post.body?.response,
-    actualMessage: outbound,
-  });
-
-  return { ok: true, ...outcome, expected, actual, response: post.body };
-}
-
-async function diverge({ shadow, body, runId, inputs }) {
-  if (!inputs) return null;
-
-  await divergenceConfig.load();
-  const { enabled, baseUrl, timeoutMs } = divergenceConfig.getOracleConnection();
-  if (!enabled || !baseUrl) return null;
-
-  const request = {
-    runId,
-    body,
-    clinicalData: inputs.clinicalData,
-    input: inputs.input || [],
-    model: inputs.model,
-    enabledTools: inputs.toolIds || [],
-  };
-
-  const connection = {
-    baseUrl,
-    apiKey: runtimeConfig.get('CLINICAL_AGENT_BENCH_KEY', ''),
-    timeoutMs,
-  };
-
-  return runDivergence({ request, connection, trace: shadow?.context?.trace, outbound: shadow?.result?.output || '' });
-}
-
-module.exports = {
-  diverge,
-};

package/lib/clinical/services/seedService.js

@@ -1,21 +0,0 @@
-const { createProjectorRegistry } = require('../helpers/projectorHelper');
-const { validateSeed } = require('../helpers/seedHelper');
-
-const registry = createProjectorRegistry({
-  label: 'seed projector',
-  assemble: (items) => {
-    const seed = {};
-    const seen = new Set();
-    for (const { name, content } of items) {
-      if (seen.has(name)) throw new Error(`duplicate seed file name: '${name}'`);
-      seen.add(name);
-      if (content !== undefined) seed[name] = content;
-    }
-    return validateSeed(seed);
-  },
-});
-
-module.exports = {
-  registerSeedProjector: registry.register,
-  projectSeed: registry.project,
-};