@peopl-health/nexus 5.9.0-dev.921 → 6.0.0-dev.611

package/lib/clinical/AssistantProcessor.js

@@ -2,14 +2,10 @@ const { sanitizeOutput } = require('../utils/formatUtils');
 
 const { getThread } = require('../helpers/threadHelper');
 const { runAssistantWithRetries } = require('./helpers/assistantHelper');
-const { overlayCohortPreset } = require('./helpers/cohortHelper');
 
 const { forkShadowTurn } = require('./services/shadowService');
 const { diverge } = require('./services/divergenceService');
 const { getAssistantById } = require('./services/assistantResolver');
-const { maybeSendBridge } = require('./services/bridgeService');
-const { getBridgePresetId } = require('./flags/bridgeConfig');
-const { ToolRuntimeContext } = require('./context/ToolRuntimeContext');
 
 class AssistantProcessor {
   constructor({ mode = 'local', queueAdapter = null, sendMessage = null, phiProcessor = null, storeRunMetrics = null }) {
@@ -22,15 +18,14 @@ class AssistantProcessor {
   setSendMessage(fn) { this.sendMessage = fn; }
 
   async resolveThread(code) {
-    const stored = await getThread(code);
-    if (!stored) return null;
-    const thread = await overlayCohortPreset(stored);
+    const thread = await getThread(code);
+    if (!thread) return null;
     const assistant = getAssistantById(thread.getAssistantId(), thread);
     return { thread, assistant };
   }
 
   async executeLLM(thread, assistant, runOptions = {}, message = null) {
-    if (!runOptions.shadow && !thread.isInCohort) {
+    if (!runOptions.shadow) {
       forkShadowTurn({
         thread,
         message,
@@ -42,33 +37,11 @@ class AssistantProcessor {
       });
     }
 
-    if (thread.isInCohort && !runOptions.toolRuntimeContext && runOptions.runId && thread.code) {
-      runOptions.toolRuntimeContext = new ToolRuntimeContext({ patientCode: thread.code, turnId: runOptions.runId });
-    }
-
     const ctx = runOptions.toolRuntimeContext || null;
     assistant.toolRuntimeContext = ctx;
-    if (ctx && thread) thread.toolRuntimeContext = ctx;
-
-    const runConfig = { ...runOptions, phiProcessor: this.phiProcessor };
-    const isClinicalAgentTurn = thread.preset_id === getBridgePresetId();
-    if (!runOptions.shadow && isClinicalAgentTurn && message?.body && this.sendMessage) {
-      let decision = null;
-      runConfig.onFirstIteration = (args) => {
-        decision = decision || maybeSendBridge({
-          ...args,
-          code: thread.code,
-          turnId: runOptions.runId || null,
-          traceId: ctx?.trace?._id ? String(ctx.trace._id) : null,
-          shouldContinue: runOptions.shouldContinue,
-          sendMessage: this.sendMessage,
-        });
-        return decision;
-      };
-    }
 
     const startTime = Date.now();
-    const runResult = await runAssistantWithRetries(thread, assistant, runConfig, message);
+    const runResult = await runAssistantWithRetries(thread, assistant, { ...runOptions, phiProcessor: this.phiProcessor }, message);
     const predictionTimeMs = Date.now() - startTime;
 
     const output = sanitizeOutput(runResult?.output);
@@ -88,8 +61,6 @@ class AssistantProcessor {
       prompt: run?.prompt || null,
       preset: run?.preset || null,
       response_id: run?.id || null,
-      turnId: runOptions.runId || null,
-      traceId: ctx?.trace?._id ? String(ctx.trace._id) : null,
       run,
       predictionTimeMs,
       retries: runResult?.retries || 0,
@@ -124,7 +95,7 @@ class AssistantProcessor {
   async sendResponse(code, result) {
     if (!this.sendMessage) throw new Error('sendMessage function not configured');
     if (!result?.output) return null;
-    await this.sendMessage({ code, body: result.output, processed: true, origin: 'assistant', tools_executed: result.tools_executed, prompt: result.prompt, preset: result.preset, response_id: result.response_id, turnId: result.turnId, traceId: result.traceId });
+    await this.sendMessage({ code, body: result.output, processed: true, origin: 'assistant', tools_executed: result.tools_executed, prompt: result.prompt, preset: result.preset, response_id: result.response_id });
     return result.output;
   }
 }

package/lib/clinical/config/divergenceConfig.js

@@ -46,23 +46,7 @@ async function load() {
   const stochastic = { ...STOCHASTIC_DEFAULTS, ...(parsedStochastic || {}) };
   if (stochastic.enabled && !stochastic.presetId) throw new Error('divergence config STOCHASTIC.presetId is required when enabled');
 
-  let safetyFlagPatterns = [];
-  if (byKey.SAFETY_FLAG_PATTERNS) {
-    const parsedPatterns = safeParseArray(byKey.SAFETY_FLAG_PATTERNS);
-    if (!parsedPatterns) throw new Error('divergence config SAFETY_FLAG_PATTERNS is not a JSON array');
-    safetyFlagPatterns = parsedPatterns.map((row) => {
-      if (!isPlainObject(row)) throw new Error('divergence config SAFETY_FLAG_PATTERNS row is not an object');
-      const { flag, pattern } = row;
-      if (!flag || !pattern) throw new Error('divergence config SAFETY_FLAG_PATTERNS row missing flag or pattern');
-      try {
-        return { flag, re: new RegExp(pattern, 'i') };
-      } catch (err) {
-        throw new Error(`divergence config SAFETY_FLAG_PATTERNS pattern for ${flag} is not a valid regex: ${err.message}`);
-      }
-    });
-  }
-
-  const config = { FIELDS: fields, ORACLE_CONNECTION: oracleConnection, STOCHASTIC: stochastic, SAFETY_FLAG_PATTERNS: safetyFlagPatterns };
+  const config = { FIELDS: fields, ORACLE_CONNECTION: oracleConnection, STOCHASTIC: stochastic };
   cache.set(CACHE_KEY, config);
   return config;
 }
@@ -76,5 +60,4 @@ module.exports = {
   getFields: () => get('FIELDS'),
   getOracleConnection: () => get('ORACLE_CONNECTION'),
   getStochastic: () => get('STOCHASTIC'),
-  getSafetyFlagPatterns: () => get('SAFETY_FLAG_PATTERNS'),
 };

package/lib/clinical/config/llmConfig.js

@@ -7,8 +7,7 @@ const state = {
   anthropicClient: null,
   openaiClient: null,
   provider: null,
-  variant: null,
-  gatewayProvider: null
+  variant: null
 };
 
 const setOpenAIProvider = (provider) => {
@@ -39,11 +38,6 @@ const configureOpenAIProvider = (config = {}) => {
   return provider;
 };
 
-const requireGatewayProvider = () => {
-  if (!state.gatewayProvider) state.gatewayProvider = createLLMProvider({ variant: 'gateway' });
-  return state.gatewayProvider;
-};
-
 const getAnthropicClient = () => {
   if (state.anthropicClient) return state.anthropicClient;
   const apiKey = runtimeConfig.get('ANTHROPIC_API_KEY');
@@ -63,7 +57,6 @@ const _resetState = () => {
   state.openaiClient = null;
   state.provider = null;
   state.variant = null;
-  state.gatewayProvider = null;
 };
 
 module.exports = {
@@ -74,7 +67,6 @@ module.exports = {
   setOpenAIProvider,
   getOpenAIProvider,
   requireOpenAIProvider,
-  requireGatewayProvider,
   configureOpenAIProvider,
   _resetState
 };

package/lib/clinical/context/ToolRuntimeContext.js

@@ -7,6 +7,7 @@ class ToolRuntimeContext {
     sessionId = null,
     repos = {},
     contextSource = null,
+    thread = null,
   } = {}) {
     if (typeof patientCode !== 'string' || !patientCode) {
       throw new Error('ToolRuntimeContext requires a non-empty patientCode');
@@ -23,7 +24,7 @@ class ToolRuntimeContext {
     this.sessionId = sessionId;
     this.repos = repos;
     this.contextSource = contextSource;
-    this.enabledSkills = [];
+    this.thread = thread;
     this.toolHistory = [];
     this.safetyArtifact = null;
     this.palliativeAssessment = null;

package/lib/clinical/helpers/divergenceHelper.js

@@ -29,17 +29,6 @@ const COMPARATORS = {
   set: (expected, actual) => isDeepStrictEqual(new Set(expected || []), new Set(actual || [])),
 };
 
-function oracleToolsInvoked(turn = {}, enabledTools = null) {
-  const summary = Array.isArray(turn.state_mutations_summary) ? turn.state_mutations_summary : [];
-  const allow = Array.isArray(enabledTools) ? new Set(enabledTools) : null;
-  const names = summary
-    .filter((entry) => typeof entry === 'string')
-    .map((entry) => entry.split('(')[0].trim())
-    .filter(Boolean)
-    .filter((name) => !allow || allow.has(name));
-  return [...new Set(names)];
-}
-
 const OUTCOME_RULES = [
   [({ deterministic }) => deterministic.divergences.some((d) => d.isEmergencyFlip), 'review'],
   [({ stochastic }) => stochastic.verdict === 'fail', 'fail'],
@@ -107,6 +96,5 @@ async function classify({ expected, actual, expectedMessage, actualMessage }) {
 
 module.exports = {
   deterministicDivergence,
-  oracleToolsInvoked,
   classify,
 };

package/lib/clinical/index.js

@@ -24,7 +24,6 @@ const llmConfigModule = require('./config/llmConfig');
 const { ToolRuntimeContext } = require('./context/ToolRuntimeContext');
 
 const { getCtcaeCatalog } = require('./stores/CtcaeCatalog');
-const { registerClinicalTools } = require('./tools/registerClinicalTools');
 
 async function initialize() {
   await getCtcaeCatalog().initialize();
@@ -32,7 +31,6 @@ async function initialize() {
 
 module.exports = {
   initialize,
-  registerClinicalTools,
   createLLMProvider,
   PROVIDER_VARIANTS,
   OpenAIResponsesProvider,

package/lib/clinical/memory/DefaultMemoryManager.js

@@ -1,7 +1,5 @@
 const { handlePendingFunctionCalls: handlePendingFunctionCallsUtil } = require('../providers/OpenAIResponsesProviderTools');
-
 const { Follow_Up_ID } = require('../../config/airtableConfig');
-const runtimeConfig = require('../../config/runtimeConfig');
 
 const { logger } = require('../../utils/logger');
 
@@ -9,11 +7,11 @@ const { getMessageTools, formatMessage } = require('../../helpers/messageHelper'
 
 const { getRecordByFilter } = require('../../services/airtableService');
 const { getMessages } = require('../../services/messageService');
-
+const runtimeConfig = require('../../config/runtimeConfig');
 const { MemoryManager } = require('./MemoryManager');
 
 const DEFAULT_MAX_HISTORICAL_MESSAGES = 50;
-const OPERATOR_TURN_PREFIX = '[SYSTEM]';
+const ALLOWED_SYSTEM_ROLES = new Set(['system', 'developer']);
 
 class DefaultMemoryManager extends MemoryManager {
   constructor(options = {}) {
@@ -38,15 +36,13 @@ class DefaultMemoryManager extends MemoryManager {
 
       const context = allMessages.reverse().flatMap(msg => {
         const toolItems = getMessageTools(msg);
-        const role = this._resolveContextRole(msg);
-        const prefix = this._isInlineOperatorTurn(msg, role) ? `${OPERATOR_TURN_PREFIX} ` : '';
         const contentItems = formatMessage(msg)
-          .filter(Boolean)
           .map(content => ({
-            role,
-            content: `${prefix}${content}`,
+            role: this._resolveContextRole(msg),
+            content: content,
             type: 'message'
-          }));
+          }))
+          .filter(item => item.content);
         return [...toolItems, ...contentItems];
       });
 
@@ -61,19 +57,13 @@ class DefaultMemoryManager extends MemoryManager {
     if (msg.origin === 'patient') return 'user';
     if (msg.origin === 'system' && msg.raw?.role) {
       const role = String(msg.raw.role).trim().toLowerCase();
-      if (role === 'developer') return 'developer';
-      if (role !== 'system') {
-        logger.warn('[DefaultMemoryManager] Unrecognized operator role, treating as an inline turn', { role: msg.raw.role });
-      }
-      return 'user';
+      if (ALLOWED_SYSTEM_ROLES.has(role)) return role;
+      logger.warn('[DefaultMemoryManager] Unexpected system message role, using fallback', { role: msg.raw.role });
+      return 'system';
     }
     return 'assistant';
   }
 
-  _isInlineOperatorTurn(msg, role) {
-    return msg.origin === 'system' && role === 'user';
-  }
-
   async processResponse(response, thread) {
     this._logActivity('Processing response', { threadCode: thread.code, responseId: response.id });
     try {

package/lib/clinical/models/turnTraceModel.js

@@ -14,7 +14,6 @@ const iterationSchema = new mongoose.Schema({
   reasoning: { type: mongoose.Schema.Types.Mixed, default: null },
   responseId: { type: String, default: null },
   toolCallIds: { type: [String], default: [] },
-  toolNames: { type: [String], default: [] },
   durationMs: { type: Number, default: null },
 }, { _id: false });
 
@@ -53,9 +52,6 @@ turnTraceSchema.methods.toDecision = function toDecision() {
     outbound_purpose: signals.outboundPurpose || null,
     branch_taken: signals.branchTaken || null,
     red_flags_matched: decision.redFlagsMatched || [],
-    tools_invoked: [...new Set(this.iterations.flatMap((it) => it.toolNames || []))],
-    escalation_justification: signals.medicalEscalation?.urgencyJustification || null,
-    model_identifier: this.iterations.at(-1)?.model || null,
   };
 };
 
@@ -70,26 +66,17 @@ function buildIterationRecord(response, durationMs, apiCallConfig = {}) {
   const usage = response?.usage || {};
   const inputDetails = usage.input_tokens_details || {};
   const output = response?.output || [];
-  const content = Array.isArray(response?.content) ? response.content : [];
   return {
     model: apiCallConfig?.model || null,
     temperature: apiCallConfig?.temperature ?? null,
-    maxOutputTokens: apiCallConfig?.max_output_tokens || apiCallConfig?.max_tokens || null,
+    maxOutputTokens: apiCallConfig?.max_output_tokens || null,
     stopReason: response?.stop_reason || response?.status || null,
     inputTokens: usage.input_tokens || 0,
     outputTokens: usage.output_tokens || 0,
-    cacheCreationTokens: usage.cache_creation_tokens || usage.cache_creation_input_tokens || inputDetails.cache_creation_tokens || 0,
-    cacheReadTokens: usage.cache_read_tokens || usage.cache_read_input_tokens || inputDetails.cached_tokens || 0,
-    reasoning: output.find((item) => item.type === 'reasoning')?.summary
-      || content.find((block) => block.type === 'thinking')?.thinking || null,
-    toolCallIds: [
-      ...output.filter((item) => item.type === 'function_call').map((item) => item.call_id),
-      ...content.filter((block) => block.type === 'tool_use').map((block) => block.id),
-    ].filter((id) => typeof id === 'string' && id.length > 0),
-    toolNames: [
-      ...output.filter((item) => item.type === 'function_call' && typeof item.call_id === 'string' && item.call_id.length > 0).map((item) => item.name),
-      ...content.filter((block) => block.type === 'tool_use' && typeof block.id === 'string' && block.id.length > 0).map((block) => block.name),
-    ].filter((name) => typeof name === 'string' && name.length > 0),
+    cacheCreationTokens: usage.cache_creation_tokens || inputDetails.cache_creation_tokens || 0,
+    cacheReadTokens: usage.cache_read_tokens || inputDetails.cached_tokens || 0,
+    reasoning: output.find((item) => item.type === 'reasoning')?.summary || null,
+    toolCallIds: output.filter((item) => item.type === 'function_call').map((item) => item.call_id),
     responseId: response?.id || null,
     durationMs,
   };