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

package/lib/clinical/providers/BaseLLMProvider.js

@@ -1,6 +1,5 @@
 const { DefaultMemoryManager } = require('../memory/DefaultMemoryManager');
 const { composePrompt, resolveTools } = require('../services/promptComposerService');
-const { resolveEnabledSkills } = require('../services/skillService');
 const runtimeConfig = require('../../config/runtimeConfig');
 const { logger } = require('../../utils/logger');
 const { getCurrentMexicoDateTime } = require('../../utils/dateUtils');
@@ -13,10 +12,6 @@ const { logBugReportToAirtable } = require('../../controllers/bugReportControlle
 
 const DEFAULT_MAX_CONVERSATION_RETRIES = 3;
 const CONVERSATION_CONTINUATION = '(continuar)';
-const NEGATIVE_GUIDANCE_MARKER = '**When NOT to call';
-const TERMINAL_DELIVERY_TOOLS = new Set(['DeliverPatientMessage']);
-const DELIVERY_NUDGE = 'sistema: el turno no puede cerrar sin un mensaje para el paciente. Llama ahora a DeliverPatientMessage con message_text en español. No repitas herramientas clínicas ya ejecutadas en este turno.';
-const MAX_DELIVERY_NUDGES = 1;
 
 class BaseLLMProvider {
   constructor(options = {}) {
@@ -41,13 +36,12 @@ class BaseLLMProvider {
       instructions = null, additionalInstructions = null, metadata = {},
       assistant, promptVersion = null, promptVariables = null,
       toolChoice = 'auto', prePromptResult = null, phiProcessor = null,
-      shadow = false, shouldContinue = null, onFirstIteration = null
+      shadow = false, shouldContinue = null
     } = config;
     const trace = assistant?.toolRuntimeContext?.trace || null;
 
     const {
-      resolvedPrompt, interpolatedVariables, snippetIds, promptId: resolvedPromptId,
-      presetToolIds, presetSkillIds,
+      resolvedPrompt, snippetIds, promptId: resolvedPromptId, presetToolIds,
       presetId: resolvedPresetId, presetVersion: resolvedPresetVersion, modelConfig,
     } = await composePrompt({ presetId, presetVersion, promptId: assistantId, variables: promptVariables });
 
@@ -55,18 +49,9 @@ class BaseLLMProvider {
       promptId: resolvedPromptId || assistantId, assistant, presetToolIds,
     });
 
-    if (assistant?.toolRuntimeContext) {
-      assistant.toolRuntimeContext.enabledSkills = await resolveEnabledSkills(presetSkillIds);
-    }
-
-    const resolvedSchemas = this._resolveToolSchemas({ assistant, toolIds, filtered, toolDescriptions });
-    const { toolChoice: flooredToolChoice, toolSchemas, narrowed } = this._applyDeliveryFloor(toolChoice, resolvedSchemas, prePromptResult?.toolChoice);
-    const effectiveToolIds = narrowed ? toolSchemas.map(s => s.function?.name).filter(Boolean) : toolIds;
-    const devContent = this._buildInstructions({ resolvedPrompt, toolSchemas, prePromptResult });
-    const auditedPrompt = additionalInstructions
-      ? `${devContent}\n\n${this._operatorInstructionTurn(additionalInstructions, modelConfig).content}`
-      : devContent;
-    const input = this._buildInput({ context, prePromptResult, additionalInstructions, promptVariables, modelConfig, interpolatedVariables });
+    const toolSchemas = this._resolveToolSchemas({ assistant, toolIds, filtered, toolDescriptions });
+    const devContent = this._buildInstructions({ resolvedPrompt, toolSchemas, prePromptResult, additionalInstructions });
+    const input = this._buildInput({ context, prePromptResult, additionalInstructions, promptVariables, modelConfig });
 
     // Capture before _invokeModel: the divergence oracle replays this shadow request shape.
     if (shadow && assistant?.toolRuntimeContext) {
@@ -79,19 +64,19 @@ class BaseLLMProvider {
         },
         input,
         model: modelConfig?.model || null,
-        toolIds: Array.isArray(effectiveToolIds) ? effectiveToolIds : [],
+        toolIds: Array.isArray(toolIds) ? toolIds : [],
         additionalInstructions: additionalInstructions || null,
       };
     }
 
-    trace?.setPrompt({ resolved: auditedPrompt, resolvedPresetId, resolvedPresetVersion });
+    trace?.setPrompt({ resolved: devContent, resolvedPresetId, resolvedPresetVersion });
 
     const { response, toolsExecuted, retries, usage } = await this._invokeModel({
       instructions: instructions || devContent || '',
       input,
       toolSchemas,
-      toolChoice: prePromptResult?.toolChoice || flooredToolChoice,
-      followUpToolChoice: flooredToolChoice,
+      toolChoice: prePromptResult?.toolChoice || toolChoice,
+      followUpToolChoice: toolChoice,
       modelConfig,
       metadata,
       assistant,
@@ -103,7 +88,6 @@ class BaseLLMProvider {
       trace,
       shadow,
       shouldContinue,
-      onFirstIteration,
     });
 
     return {
@@ -114,9 +98,9 @@ class BaseLLMProvider {
       tools_executed: toolsExecuted,
       retries,
       usage,
-      resolved_prompt: auditedPrompt,
+      resolved_prompt: devContent,
       snippet_ids: snippetIds,
-      tool_ids: effectiveToolIds,
+      tool_ids: toolIds,
       preset_id: resolvedPresetId,
       preset_version: resolvedPresetVersion,
       preset: resolvedPresetId ? { id: resolvedPresetId, version: resolvedPresetVersion } : null,
@@ -140,17 +124,13 @@ class BaseLLMProvider {
     return activeToolSchemas.map(s => {
       const name = s.function?.name;
       if (name && toolDescriptions[name]) {
-        if (s.function.description?.includes(NEGATIVE_GUIDANCE_MARKER)
-          && !toolDescriptions[name].includes(NEGATIVE_GUIDANCE_MARKER)) {
-          logger.warn('[BaseLLMProvider] Airtable description drops the when-NOT-to-call guidance written in code', { tool: name });
-        }
         return { ...s, function: { ...s.function, description: toolDescriptions[name] } };
       }
       return s;
     });
   }
 
-  _buildInstructions({ resolvedPrompt, toolSchemas, prePromptResult }) {
+  _buildInstructions({ resolvedPrompt, toolSchemas, prePromptResult, additionalInstructions }) {
     let devContent = resolvedPrompt;
     if (toolSchemas.length > 0) {
       const toolNames = toolSchemas.map(s => s.function?.name).join(', ');
@@ -159,14 +139,21 @@ class BaseLLMProvider {
     if (prePromptResult?.additionalInstructions) {
       devContent += `\n\n${prePromptResult.additionalInstructions}`;
     }
+    if (additionalInstructions) {
+      devContent += this._operatorInstructionSuffix(additionalInstructions);
+    }
     return devContent;
   }
 
-  _operatorInstructionTurn(additionalInstructions) {
-    return { role: 'developer', content: `[DIRECTIVA DEL OPERADOR (prioritaria) para tu próxima respuesta al paciente]: ${additionalInstructions}` };
+  _operatorInstructionSuffix(additionalInstructions) {
+    return `\n\n[DIRECTIVA DEL OPERADOR (prioritaria) para tu próxima respuesta al paciente]: ${additionalInstructions}`;
+  }
+
+  _operatorInstructionTurn() {
+    return { role: 'user', content: CONVERSATION_CONTINUATION };
   }
 
-  _buildInput({ context, prePromptResult, additionalInstructions, promptVariables, modelConfig = null, interpolatedVariables = [] }) {
+  _buildInput({ context, prePromptResult, additionalInstructions, promptVariables, modelConfig = null }) {
     let messages = this._convertItemsToApiFormat(context || []);
     if (Array.isArray(prePromptResult?.additionalMessages) && prePromptResult.additionalMessages.length > 0) {
       messages = [...messages, ...this._convertItemsToApiFormat(prePromptResult.additionalMessages)];
@@ -174,35 +161,7 @@ class BaseLLMProvider {
     if (additionalInstructions) {
       messages = [...messages, this._operatorInstructionTurn(additionalInstructions, modelConfig)];
     }
-    return this._sanitizeInput([
-      ...this._buildMemoryMessage(promptVariables),
-      ...this._buildClinicalMessage(promptVariables, interpolatedVariables),
-      ...this._buildClockMessage(promptVariables),
-      ...messages,
-    ]);
-  }
-
-  _buildClinicalMessage(promptVariables, interpolatedVariables = []) {
-    const inPrompt = new Set(interpolatedVariables);
-    const context = this._clinicalText(promptVariables?.clinical_context, 'clinical_context');
-    const symptoms = this._clinicalText(promptVariables?.last_symptoms, 'last_symptoms');
-    const parts = [];
-    if (context && !inPrompt.has('clinical_context')) {
-      parts.push(`## Contexto clínico del paciente\n${context}`);
-    }
-    if (symptoms && !inPrompt.has('last_symptoms')) {
-      parts.push(`## Síntomas recientes\n${symptoms}`);
-    }
-    if (parts.length === 0) return [];
-    return [{ role: 'developer', content: parts.join('\n\n') }];
-  }
-
-  _clinicalText(value, field) {
-    if (typeof value === 'string') return value.trim();
-    if (value != null) {
-      logger.warn('[BaseLLMProvider] Non-string clinical variable, omitting from runtime context', { field, type: typeof value });
-    }
-    return '';
+    return this._sanitizeInput([...this._buildMemoryMessage(promptVariables), ...messages]);
   }
 
   _buildMemoryMessage(promptVariables) {
@@ -213,14 +172,6 @@ class BaseLLMProvider {
     return [{ role: 'developer', content: `Usa la siguiente información que conoces del paciente para personalizar tu respuesta. Adapta tu tono, contenido o recomendaciones según estas preferencias y contexto cuando sea relevante. No menciones que tienes esta información almacenada.\n\n${memoryParts.join('\n\n')}` }];
   }
 
-  // Delivers the clock after the breakpoint, so a minute-granular date stops rewriting the cached
-  // prefix. Off until {{current_date}} leaves the prompt body, or the date would be sent twice.
-  _buildClockMessage(promptVariables) {
-    if (runtimeConfig.get('CLOCK_OUTSIDE_PROMPT') !== 'true') return [];
-    if (!promptVariables?.current_date) return [];
-    return [{ role: 'developer', content: `Fecha y hora actual: ${promptVariables.current_date}` }];
-  }
-
   async _invokeModel() {
     throw new Error(`${this.constructor.name} must implement _invokeModel()`);
   }
@@ -316,9 +267,7 @@ class BaseLLMProvider {
         logger.info('[runConversation] Attempt', { attempt, maxRetries, threadId, assistantId });
 
         const result = await this._executeConversation(config);
-        // DeliverPatientMessage is the curated patient reply; prefer it over any model narration in the final response.
-        const delivered = this._extractDeliveredMessage(config, result);
-        const extractedOutput = delivered?.trim() ? delivered : this._extractMessageOutput(result);
+        const extractedOutput = this._extractMessageOutput(result);
 
         if (extractedOutput?.trim()) {
           result.output_text = extractedOutput;
@@ -352,41 +301,6 @@ class BaseLLMProvider {
     }
   }
 
-  _toolSucceeded(t) {
-    // The executor sets success=true unless the call threw; a tool can also fail by returning {success:false} in its output.
-    if (!t || t.success === false) return false;
-    if (typeof t.tool_output === 'string') {
-      try { if (JSON.parse(t.tool_output)?.success === false) return false; } catch { /* non-JSON output */ }
-    }
-    return true;
-  }
-
-  _deliveryCommitted(toolsExecuted) {
-    return (toolsExecuted || []).some(t => TERMINAL_DELIVERY_TOOLS.has(t?.tool_name) && this._toolSucceeded(t));
-  }
-
-  // On a preset whose only patient-visible output path is a delivery tool, 'none' leaves the turn nothing it may
-  // emit, so it retries on empty output until it throws. Read it as "only the delivery tool" instead — the
-  // side-effect guarantee the caller wanted survives the narrowing.
-  // Skipped when a pre-prompt hook forced a choice: that choice may name a tool the narrowing would drop.
-  _applyDeliveryFloor(toolChoice, toolSchemas, prePromptToolChoice = null) {
-    if (prePromptToolChoice) return { toolChoice, toolSchemas, narrowed: false };
-    if (toolChoice !== 'none') return { toolChoice, toolSchemas, narrowed: false };
-    const deliveryOnly = toolSchemas.filter(s => TERMINAL_DELIVERY_TOOLS.has(s.function?.name));
-    if (!deliveryOnly.length) return { toolChoice, toolSchemas, narrowed: false };
-    return { toolChoice: 'auto', toolSchemas: deliveryOnly, narrowed: true };
-  }
-
-  _extractDeliveredMessage(config, result) {
-    const executed = Array.isArray(result?.tools_executed) ? result.tools_executed : [];
-    // Only count a delivery from THIS run, so a stale/prior trace.outbound can't leak in.
-    const delivered = executed.some(t => t?.tool_name === 'DeliverPatientMessage' && this._toolSucceeded(t));
-    if (!delivered) return '';
-    // trace.outbound is the decoded/rendered outbound the handler wrote; message_text (raw tool arg) may be PHI-tokenized, so it is not used.
-    const traceOutbound = config?.assistant?.toolRuntimeContext?.trace?.outbound;
-    return (typeof traceOutbound === 'string' && traceOutbound.trim()) ? traceOutbound : '';
-  }
-
   _normalizeThread(thread) {
     return {
       conversationId: thread.conversation_id || thread.getConversationId?.(),
@@ -523,7 +437,4 @@ class BaseLLMProvider {
 module.exports = {
   BaseLLMProvider,
   CONVERSATION_CONTINUATION,
-  DELIVERY_NUDGE,
-  MAX_DELIVERY_NUDGES,
-  TERMINAL_DELIVERY_TOOLS,
 };

package/lib/clinical/providers/GatewayProvider.js

@@ -74,10 +74,10 @@ class GatewayProvider extends BaseLLMProvider {
       model = composed.modelConfig?.model || null;
     }
     const { vendor, model: routedModel } = this._route(model);
-    if (vendor !== 'openai' && vendor !== 'anthropic') {
-      throw new Error(`runStructured is only supported for OpenAI and Anthropic models; routed model '${model}' resolved to '${vendor}'`);
+    if (vendor !== 'openai') {
+      throw new Error(`runStructured is only supported for OpenAI models; routed model '${model}' resolved to '${vendor}'`);
     }
-    return this._sub(vendor).runStructured({ ...params, model: routedModel });
+    return this._sub('openai').runStructured({ ...params, model: routedModel });
   }
 }
 

package/lib/clinical/providers/OpenAIResponsesProvider.js

@@ -7,23 +7,10 @@ const { safeParse } = require('../../utils/jsonUtils');
 
 const { logger } = require('../../utils/logger');
 
-const runtimeConfig = require('../../config/runtimeConfig');
-
 const { BaseLLMProvider } = require('./BaseLLMProvider');
 const { handleFunctionCalls } = require('./OpenAIResponsesProviderTools');
 
-const DEFAULT_MAX_FUNCTION_ROUNDS = 12;
-
-function resolveMaxFunctionRounds(explicit) {
-  if (Number.isInteger(explicit) && explicit > 0) return explicit;
-  const raw = runtimeConfig.get('MAX_FUNCTION_ROUNDS');
-  const n = parseInt(raw, 10);
-  if (n > 0) return n;
-  if (raw !== undefined) {
-    logger.warn('[OpenAIResponsesProvider] Invalid MAX_FUNCTION_ROUNDS, falling back to default', { value: raw, default: DEFAULT_MAX_FUNCTION_ROUNDS });
-  }
-  return DEFAULT_MAX_FUNCTION_ROUNDS;
-}
+const DEFAULT_MAX_FUNCTION_ROUNDS = 5;
 
 class OpenAIResponsesProvider extends BaseLLMProvider {
   constructor(options = {}) {
@@ -33,7 +20,7 @@ class OpenAIResponsesProvider extends BaseLLMProvider {
       organization,
       client,
       defaultModels = {},
-      maxFunctionRounds,
+      maxFunctionRounds = DEFAULT_MAX_FUNCTION_ROUNDS,
     } = options;
 
     if (!client && !apiKey) {
@@ -41,7 +28,7 @@ class OpenAIResponsesProvider extends BaseLLMProvider {
     }
 
     this.client = client || new OpenAI({ apiKey, organization });
-    this.maxFunctionRounds = resolveMaxFunctionRounds(maxFunctionRounds);
+    this.maxFunctionRounds = maxFunctionRounds;
     this.defaults = {
       responseModel: 'gpt-5',
       chatModel: 'gpt-4o-mini',
@@ -66,7 +53,7 @@ class OpenAIResponsesProvider extends BaseLLMProvider {
     instructions, input, toolSchemas = [], toolChoice = 'auto', followUpToolChoice = 'auto',
     modelConfig, metadata = {}, assistant, phiProcessor = null,
     promptVariables = null, promptVersion = null, resolvedPromptId = null, resolvedPresetId = null, trace = null,
-    shadow = false, shouldContinue = null, onFirstIteration = null
+    shadow = false, shouldContinue = null
   }, options = {}) {
     const executeTools = options.toolExecutor || handleFunctionCalls;
     const shadowSuperseded = () => shadow && !shouldContinue();
@@ -116,23 +103,6 @@ class OpenAIResponsesProvider extends BaseLLMProvider {
     let producingIteration = trace?.addIteration({ response, durationMs, apiCallConfig }) || null;
     let finalResponse = response;
 
-    let bridgeNote = null;
-    if (onFirstIteration) {
-      const narrationText = (response.output || [])
-        .filter(item => item.type === 'message')
-        .map(item => this._messageItemToText(item))
-        .filter(Boolean)
-        .join(' ')
-        .trim();
-      const hasToolCalls = Boolean(assistant) && (response.output || []).some(item => item.type === 'function_call');
-      try {
-        const decision = onFirstIteration({ narrationText, hasToolCalls });
-        if (decision?.sent && decision.dedupNote) bridgeNote = decision.dedupNote;
-      } catch (err) {
-        logger.warn('[OpenAIResponsesProvider] bridge callback failed', { error: err.message });
-      }
-    }
-
     if (assistant && response.output) {
       let currentInput = [...input];
 
@@ -150,10 +120,6 @@ class OpenAIResponsesProvider extends BaseLLMProvider {
         const { outputs, toolsExecuted } = await executeTools(functionCalls, assistant, phiProcessor, producingIteration);
 
         currentInput.push(...finalResponse.output, ...outputs);
-        if (bridgeNote) {
-          currentInput.push({ role: 'developer', content: bridgeNote });
-          bridgeNote = null;
-        }
         allToolsExecuted.push(...toolsExecuted);
 
         const { result: { result: followUp, retries: followUpRetries }, durationMs: followUpDurationMs } = await withTiming(() => makeAPICall(currentInput));
@@ -162,14 +128,6 @@ class OpenAIResponsesProvider extends BaseLLMProvider {
         producingIteration = trace?.addIteration({ response: followUp, durationMs: followUpDurationMs, apiCallConfig }) || null;
         finalResponse = followUp;
       }
-
-      // Budget exhausted mid-work: the loop stopped while the model still wanted tools, so the reply may be empty. Make it
-      // visible — but not on a shadow-supersede break (:142), which also exits with pending calls and is not exhaustion.
-      const pendingCalls = (finalResponse.output || []).filter(item => item.type === 'function_call');
-      if (pendingCalls.length && !shadowSuperseded()) {
-        logger.warn('[OpenAIResponsesProvider] Tool-iteration budget exhausted with pending tool calls', { maxFunctionRounds: this.maxFunctionRounds, pending: pendingCalls.map(c => c.name) });
-        trace?.setSignals?.({ toolBudgetExhausted: true });
-      }
     }
 
     return { response: finalResponse, toolCalls: allToolCalls, toolsExecuted: allToolsExecuted, retries: totalRetries, usage: accumulatedUsage };

package/lib/clinical/services/divergenceService.js

@@ -1,6 +1,6 @@
 const divergenceConfig = require('../config/divergenceConfig');
 const { getDivergenceModel } = require('../models/divergenceModel');
-const { classify, oracleToolsInvoked } = require('../helpers/divergenceHelper');
+const { classify } = require('../helpers/divergenceHelper');
 const runtimeConfig = require('../../config/runtimeConfig');
 const { logger } = require('../../utils/logger');
 
@@ -8,19 +8,15 @@ const { runClinicalAgent } = require('./clinicalAgentService');
 
 async function runDivergence({ request, connection, trace, actualMessage }) {
   let post;
-  const startedAt = Date.now();
   try {
     post = await runClinicalAgent(request, connection);
-    logger.debug('[divergence] oracle responded', { runId: request.runId, status: post.status, durationMs: Date.now() - startedAt });
     if (post.status !== 200) {
       return { ok: false, status: post.status, response: post.body };
     }
   } catch (error) {
-    logger.debug('[divergence] oracle errored', { runId: request.runId, error: error.message, durationMs: Date.now() - startedAt });
     return { ok: false, status: 503, response: { error: error.message } };
   }
-  const expectedTurn = post.body?.run?.sessions?.[0]?.turns?.[0] || {};
-  const expected = { ...expectedTurn, tools_invoked: oracleToolsInvoked(expectedTurn, request.enabledTools) };
+  const expected = post.body?.run?.sessions?.[0]?.turns?.[0] || {};
   const expectedMessage = post.body?.response || '';
 
   const actual = trace.toDecision();
@@ -34,22 +30,12 @@ async function runDivergence({ request, connection, trace, actualMessage }) {
 }
 
 async function diverge({ shadow, runId }) {
-  const code = shadow?.context?.patientCode;
   const inputs = shadow?.context?.divergenceInputs;
-  if (!inputs) {
-    logger.debug('[divergence] skip: no inputs', { runId, code });
-    return null;
-  }
-  if (!shadow.result?.completed) {
-    logger.debug('[divergence] skip: shadow incomplete', { runId, code });
-    return null;
-  }
+  if (!inputs) return null;
+  if (!shadow.result?.completed) return null;
 
   const { enabled, baseUrl, timeoutMs } = await divergenceConfig.getOracleConnection();
-  if (!enabled || !baseUrl) {
-    logger.debug('[divergence] skip: oracle off', { runId, code });
-    return null;
-  }
+  if (!enabled || !baseUrl) return null;
 
   const request = {
     runId,
@@ -59,7 +45,6 @@ async function diverge({ shadow, runId }) {
     enabledTools: inputs.toolIds || [],
     additionalInstructions: inputs.additionalInstructions || null,
   };
-  logger.debug('[divergence] oracle request', { runId, code, model: request.model, inputLen: request.input.length, tools: request.enabledTools.length });
 
   const connection = {
     baseUrl,
@@ -72,10 +57,8 @@ async function diverge({ shadow, runId }) {
   });
 
   if (report.ok) {
-    logger.debug('[divergence] classified', { runId, code, result: report.result, emergency: !!report.isEmergencyReview });
     try {
       await getDivergenceModel().record({ shadow, request, report });
-      logger.debug('[divergence] persisted', { runId, code });
     } catch (error) {
       logger.warn('[divergence] persist failed', { runId, error: error.message });
     }

package/lib/clinical/services/promptComposerService.js

@@ -15,15 +15,6 @@ const snippetCache = new MapCache({ maxSize: 200, ttl: CACHE_TTL });
 const toolCache = new MapCache({ maxSize: 50, ttl: CACHE_TTL });
 const presetCache = new MapCache({ maxSize: 50, ttl: CACHE_TTL });
 
-async function fetchConfigRecords(table, filter) {
-  const records = await getRecordByFilter(Config_ID, table, filter);
-  if (!records) {
-    logger.error('[promptComposer] Airtable read failed — refusing to widen the toolset', { table, filter });
-    throw new Error(`[promptComposer] Airtable read failed for ${table}`);
-  }
-  return records;
-}
-
 async function fetchPreset(presetId, version = null) {
   const cacheKey = version ? `preset:${presetId}:v${version}` : `preset:${presetId}:active`;
   const cached = presetCache.get(cacheKey);
@@ -33,13 +24,8 @@ async function fetchPreset(presetId, version = null) {
     ? `AND({preset_id} = "${presetId}", {version} = ${version})`
     : `AND({preset_id} = "${presetId}", {is_active} = 1)`;
 
-  const records = await fetchConfigRecords('presets', filter);
-  if (records.length > 1) {
-    logger.error('[promptComposer] Ambiguous preset — several records match; using the first', {
-      presetId, version, matched: records.length,
-    });
-  }
-  const record = records[0] || null;
+  const records = await getRecordByFilter(Config_ID, 'presets', filter);
+  const record = records?.[0] || null;
   if (record) presetCache.set(cacheKey, record);
   return record;
 }
@@ -68,10 +54,6 @@ function applyVariables(text, variables) {
   return text.replace(/\{\{(\w+)\}\}/g, (_, key) => variables[key] ?? '');
 }
 
-function variablesReferencedIn(text) {
-  return [...new Set([...(text || '').matchAll(/\{\{(\w+)\}\}/g)].map(m => m[1]))];
-}
-
 async function fetchSnippetsByRecordIds(recordIds) {
   if (!recordIds?.length) return [];
 
@@ -95,7 +77,6 @@ async function composePrompt({ presetId = null, presetVersion = null, promptId =
   let resolvedPromptId = promptId;
   let presetSnippetIds = null;
   let presetToolIds = null;
-  let presetSkillIds = null;
   let resolvedPresetVersion = null;
   let modelConfig = null;
 
@@ -103,12 +84,10 @@ async function composePrompt({ presetId = null, presetVersion = null, promptId =
     const preset = await fetchPreset(id, version);
     if (!preset) {
       logger.error('[promptComposer] Preset not found in Airtable', { presetId: id, presetVersion: version });
-      presetToolIds = [];
       return;
     }
     presetSnippetIds = preset.snippets || [];
     presetToolIds = preset.tools || [];
-    presetSkillIds = preset.skills || [];
     resolvedPresetVersion = preset.version ? String(preset.version) : null;
 
     if (preset.model_config) {
@@ -153,7 +132,6 @@ async function composePrompt({ presetId = null, presetVersion = null, promptId =
     baseContent = [...sorted.map(s => s.content), baseContent].join('\n\n');
   }
 
-  const interpolatedVariables = variablesReferencedIn(baseContent);
   const resolvedPrompt = applyVariables(baseContent, variables);
 
   logger.debug('[promptComposer] Prompt composed', {
@@ -167,11 +145,9 @@ async function composePrompt({ presetId = null, presetVersion = null, promptId =
 
   return {
     resolvedPrompt,
-    interpolatedVariables,
     snippetIds,
     promptId: resolvedPromptId,
     presetToolIds,
-    presetSkillIds,
     presetId: presetId || null,
     presetVersion: resolvedPresetVersion,
     modelConfig,
@@ -185,10 +161,16 @@ async function fetchToolsByRecordIds(recordIds) {
   const cached = toolCache.get(cacheKey);
   if (cached) return cached;
 
-  const formula = `OR(${recordIds.map(id => `RECORD_ID()="${id}"`).join(',')})`;
-  const tools = await fetchConfigRecords('tools', formula);
-  toolCache.set(cacheKey, tools);
-  return tools;
+  try {
+    const formula = `OR(${recordIds.map(id => `RECORD_ID()="${id}"`).join(',')})`;
+    const records = await getRecordByFilter(Config_ID, 'tools', formula);
+    const tools = records || [];
+    toolCache.set(cacheKey, tools);
+    return tools;
+  } catch (error) {
+    logger.warn('[promptComposer] Failed to fetch preset tools, returning empty list', { error: error.message });
+    return [];
+  }
 }
 
 async function resolveTools({ promptId, assistant, presetToolIds = null, status = runtimeConfig.getServerMode() }) {
@@ -200,12 +182,7 @@ async function resolveTools({ promptId, assistant, presetToolIds = null, status
   if (presetToolIds.length === 0) return { toolIds: [], filtered: true, descriptions: {} };
 
   const mappedTools = await fetchToolsByRecordIds(presetToolIds);
-  if (!mappedTools.length) {
-    logger.error('[promptComposer] Preset tool ids resolved to no records — running with no tools', {
-      promptId, linked: presetToolIds.length,
-    });
-    return { toolIds: [], filtered: true, descriptions: {} };
-  }
+  if (!mappedTools.length) return { toolIds: [], filtered: false, descriptions: {} };
 
   const isProd = status === 'prod';
   const activeTools = mappedTools.filter(t => !t.status || t.status === 'prod' || (!isProd && t.status === 'dev'));
@@ -217,20 +194,12 @@ async function resolveTools({ promptId, assistant, presetToolIds = null, status
     const id = tool.tool_id;
     if (hasTool(id) || assistant?.tools?.has(id)) {
       validToolIds.push(id);
-      // An Airtable column retyped away from long text would otherwise reach the model as [object Object].
-      if (typeof tool.description === 'string' && tool.description) descriptions[id] = tool.description;
+      if (tool.description) descriptions[id] = tool.description;
     } else {
-      logger.error('[promptComposer] Tool mapped in Airtable but not registered in code', { toolId: id, promptId });
+      logger.warn('[promptComposer] Tool mapped in Airtable but not registered in code', { toolId: id, promptId });
     }
   }
 
-  if (validToolIds.length === 0) {
-    logger.error('[promptComposer] Preset links tools but none resolved — the agent will run with NO tools', {
-      promptId, status, linked: presetToolIds.length,
-      dropped: mappedTools.map(t => `${t.tool_id}:${t.status || 'prod'}`),
-    });
-  }
-
   logger.debug('[promptComposer] Tools resolved', { promptId, mapped: activeTools.length, valid: validToolIds.length, filtered: true });
 
   return { toolIds: validToolIds, filtered: true, descriptions };

package/lib/clinical/services/shadowMessageService.js

@@ -14,26 +14,20 @@ async function attachShadowReplies(messages, code) {
   const assistantMessages = messages.filter((msg) => msg.origin === 'assistant' && msg.response_id);
   if (!assistantMessages.length) return messages;
 
-  const keyed = assistantMessages.filter((msg) => msg.turnId);
-  const legacy = assistantMessages.filter((msg) => !msg.turnId);
-
   let traces;
   try {
-    const or = [];
-    if (keyed.length) or.push({ turnId: { $in: keyed.map((msg) => msg.turnId) } });
-    if (legacy.length) {
-      let min = Infinity;
-      let max = -Infinity;
-      messages.forEach((msg) => {
-        const at = new Date(msg.createdAt).getTime();
-        if (at < min) min = at;
-        if (at > max) max = at;
-      });
-      or.push({ createdAt: { $gte: new Date(min - PAIRING_WINDOW_MS), $lte: new Date(max + PAIRING_WINDOW_MS) } });
-    }
+    let min = Infinity;
+    let max = -Infinity;
+    messages.forEach((msg) => {
+      const at = new Date(msg.createdAt).getTime();
+      if (at < min) min = at;
+      if (at > max) max = at;
+    });
+    const gte = new Date(min - PAIRING_WINDOW_MS);
+    const lte = new Date(max + PAIRING_WINDOW_MS);
     traces = await getTurnTraceModel()
-      .find({ patientCode: code, outbound: { $ne: null }, $or: or })
-      .select({ outbound: 1, createdAt: 1, turnId: 1 })
+      .find({ patientCode: code, outbound: { $ne: null }, createdAt: { $gte: gte, $lte: lte } })
+      .select({ outbound: 1, createdAt: 1 })
       .sort({ createdAt: 1 })
       .lean();
   } catch (error) {
@@ -43,17 +37,7 @@ async function attachShadowReplies(messages, code) {
   if (!traces.length) return messages;
 
   const used = new Set();
-
-  const traceIndexByTurnId = new Map();
-  traces.forEach((trace, index) => { if (trace.turnId) traceIndexByTurnId.set(trace.turnId, index); });
-  keyed.forEach((msg) => {
-    const index = traceIndexByTurnId.get(msg.turnId);
-    if (index === undefined || used.has(index)) return;
-    used.add(index);
-    msg.shadowReply = traces[index].outbound;
-  });
-
-  legacy.forEach((msg) => {
+  assistantMessages.forEach((msg) => {
     const at = new Date(msg.createdAt).getTime();
     let bestIndex = -1;
     let bestDelta = PAIRING_WINDOW_MS;