@peopl-health/nexus 5.69.0-dev.12579 → 5.69.0-dev.12622

package/lib/clinical/providers/AnthropicProvider.js

@@ -348,27 +348,15 @@ class AnthropicProvider extends BaseLLMProvider {
     };
     if (system) apiConfig.system = system;
 
-    // Always-thinking models (Opus/Sonnet 5.5) reject a forced tool_choice; presets opt into output_config.format instead.
-    const nativeFormat = modelConfig.structured_mode === 'output_format';
-    if (nativeFormat) {
-      const effort = modelConfig.reasoning?.effort;
-      if (effort) apiConfig.output_config = { effort: effort === 'minimal' ? 'low' : effort };
-      if (modelConfig.thinking) apiConfig.thinking = modelConfig.thinking;
-    }
-
     const spec = text || modelConfig.text;
     let tool = null;
     if (spec) {
       const format = spec.format ? spec.format : spec;
       if (!format.schema) throw new Error('runStructured: format spec has no schema');
-      if (nativeFormat) {
-        apiConfig.output_config = { ...apiConfig.output_config, format: { type: 'json_schema', schema: format.schema } };
-      } else {
-        tool = { name: format.name || 'structuredOutput', input_schema: format.schema };
-        if (format.strict !== undefined) tool.strict = format.strict;
-        apiConfig.tools = [tool];
-        apiConfig.tool_choice = { type: 'tool', name: tool.name };
-      }
+      tool = { name: format.name || 'structuredOutput', input_schema: format.schema };
+      if (format.strict !== undefined) tool.strict = format.strict;
+      apiConfig.tools = [tool];
+      apiConfig.tool_choice = { type: 'tool', name: tool.name };
     }
 
     const { result: { result }, durationMs } = await withTiming(() =>

package/lib/clinical/services/outreachSweepService.js

@@ -8,6 +8,7 @@ const { logger } = require('../../utils/logger');
 const { botIsPaused } = require('../../helpers/pausedThreadHelper');
 const { PATIENT_CONTACT_WINDOW } = require('./contingencyDispatchService');
 const { hasPendingReminderForPatient } = require('./clinicalAirtableService');
+const { WriteClaimStore } = require('./writeClaimStore');
 
 const TABLE = 'weekly_questionnaires';
 const VIEW = 'seguimiento_72hrs_principal';
@@ -49,6 +50,18 @@ const AUDIT = {
   turnId: 'seguimiento_turn_id',
 };
 
+const WEEKLY_SOURCE = 'weekly';
+const SCOPE_SOURCE = 'patient_scope';
+
+const PATIENT_TABLE = 'estado_general';
+const PATIENT_F = {
+  whatsapp: 'whatsapp_id',
+  firstName: 'first_name',
+  disableFollowUp: 'desactivar_seguimiento_48hrs',
+};
+
+const sweepClaims = new WriteClaimStore({ namespace: 'outreach_sweep', ttlMs: 8 * 24 * 60 * 60 * 1000 });
+
 const UNDELIVERED_STATUSES = ['failed', 'undelivered'];
 const CONTACT_SENT = {
   from_me: true,
@@ -62,6 +75,7 @@ const CONTACT_SENT = {
 const RECENT_OUTBOUND_HOURS = 24;
 const COLLIDING_REMINDER_MINUTES = 24 * 60;
 const INACTIVITY_DAYS = 7;
+const MAX_SILENCE_DAYS = 30;
 const TRIAGE_PROTECTION_START_MINUTE = (7 * 60) + 30;
 const TRIAGE_PROTECTION_END_MINUTE = 11 * 60;
 
@@ -202,7 +216,63 @@ function buildCandidates(rows, { now, cadence = 'daily', mode = 'continuity' })
   return { candidates, targetDays, weekday, cadence, mode };
 }
 
+function buildScopeCandidates({ patientScope, patientRows, excludedCodes }) {
+  const patients = new Map(patientScope.filter((code) => !excludedCodes.has(code))
+    .map((code) => [code, { names: new Map(), recordId: null, followUpDisabled: false }]));
+  for (const row of patientRows) {
+    const patient = patients.get(String(first(row[PATIENT_F.whatsapp]) || '').trim());
+    if (!patient) continue;
+    const name = String(first(row[PATIENT_F.firstName]) || '').trim();
+    if (name) patient.names.set(name.toLowerCase().replace(/\s+/g, ' '), name);
+    patient.recordId = patient.recordId || row._recordId;
+    if (row[PATIENT_F.disableFollowUp] === true) patient.followUpDisabled = true;
+  }
+
+  const candidates = [];
+  for (const [code, patient] of patients) {
+    if (patient.names.size !== 1) {
+      logger.info('[outreachSweep] scope candidate skipped — no single patient name', { recordId: patient.recordId });
+      continue;
+    }
+    candidates.push({
+      source: SCOPE_SOURCE,
+      patientId: null,
+      recordId: patient.recordId,
+      code,
+      name: [...patient.names.values()][0],
+      reason: 'no_triage_history',
+      followUpDisabled: patient.followUpDisabled,
+      rows: [],
+      brief: {
+        reason: 'no hay un triaje contestado que sirva como ancla clínica',
+        lastTriageAt: null,
+        maxGrade: null,
+        positiveSymptoms: [],
+      },
+    });
+  }
+  return candidates;
+}
+
+async function loadScopeCandidates({ now, viewRows, patientScope }) {
+  const weekStart = startOfLocalWeek(now).toISOString();
+  const [patientRows, weekRows] = await Promise.all([
+    airtableService.getRecordByFilter(Symptoms_ID, PATIENT_TABLE, 'TRUE()', null, Object.values(PATIENT_F), true),
+    airtableService.getRecordByFilter(
+      Symptoms_ID, TABLE, `NOT(IS_BEFORE({${F.createdAt}}, DATETIME_PARSE("${weekStart}")))`, null, [F.whatsapp],
+    ),
+  ]);
+  const excludedCodes = new Set([...viewRows, ...(weekRows || [])]
+    .map((row) => String(first(row[F.whatsapp]) || '').trim()));
+  return buildScopeCandidates({ patientScope, patientRows: patientRows || [], excludedCodes });
+}
+
+function sweepClaimKey(candidate, now) {
+  return `${candidate.code}:${startOfLocalWeek(now).format('YYYY-MM-DD')}`;
+}
+
 function opsOptedOut(candidate, { now }) {
+  if (candidate.followUpDisabled) return 'patient_follow_up_disabled';
   const weekStart = startOfLocalWeek(now);
   for (const row of candidate.rows) {
     if (first(row[F.disableFollowUp]) === true) return 'patient_follow_up_disabled';
@@ -239,7 +309,9 @@ async function rejectionReason(candidate, {
   if (opsReason) return opsReason;
   if (await botIsPaused(candidate.code, { label: '[outreachSweep]' })) return 'bot_paused';
   if (!includePreviouslySwept) {
-    const sweptReason = priorSweepReason(candidate);
+    const sweptReason = candidate.source === SCOPE_SOURCE
+      ? (await sweepClaims.has(sweepClaimKey(candidate, now)) ? 'already_swept_this_week' : null)
+      : priorSweepReason(candidate);
     if (sweptReason) return sweptReason;
 
     const since = mode === 'monday_triage_recovery'
@@ -269,11 +341,13 @@ async function rejectionReason(candidate, {
       if (!await mondayTriageStillPending(candidate)) return 'triage_no_longer_pending';
     } else if (cadence === 'daily') {
       const inactiveSince = moment.tz(now, DEFAULT_TIMEZONE).subtract(INACTIVITY_DAYS, 'days').toDate();
-      const recentInbound = await getMessages(
-        { numero: candidate.code, from_me: false, createdAt: { $gte: inactiveSince } },
-        { sort: { createdAt: -1 }, limit: 1 },
+      const silentSince = moment.tz(now, DEFAULT_TIMEZONE).subtract(MAX_SILENCE_DAYS, 'days').toDate();
+      const [lastInbound] = await getMessages(
+        { numero: candidate.code, from_me: false, createdAt: { $gte: silentSince } },
+        { select: { createdAt: 1 }, sort: { createdAt: -1 }, limit: 1 },
       );
-      if (recentInbound?.length) return 'patient_active_within_inactivity_window';
+      if (!lastInbound) return 'patient_silent_beyond_max_window';
+      if (new Date(lastInbound.createdAt) >= inactiveSince) return 'patient_active_within_inactivity_window';
 
       const lastTriageAt = candidate?.brief?.lastTriageAt;
       if (lastTriageAt && moment.tz(lastTriageAt, DEFAULT_TIMEZONE).isSameOrAfter(inactiveSince)) {
@@ -356,8 +430,11 @@ async function enrichBrief(candidate) {
 // so a second overlapping sweep sees this one and stands down. A turn that then dies leaves the
 // patient uncontacted for the week, which is the safe direction: a free-text send carries no
 // contentSid and no idempotency key, so nothing downstream would catch a duplicate.
-async function claimCandidate({ candidate, weekdayLabel, dryRun }) {
+async function claimCandidate({ candidate, weekdayLabel, dryRun, now }) {
   if (dryRun) return true;
+  if (candidate.source === SCOPE_SOURCE) {
+    return (await sweepClaims.acquire(sweepClaimKey(candidate, now))) === 'acquired';
+  }
   try {
     const claimed = await airtableService.updateRecordByFilter(
       Symptoms_ID,
@@ -380,7 +457,7 @@ async function claimCandidate({ candidate, weekdayLabel, dryRun }) {
 }
 
 async function recordOutcome({ candidate, outcome, weekdayLabel, dryRun }) {
-  if (dryRun) return;
+  if (dryRun || candidate.source === SCOPE_SOURCE) return;
   // Three outcomes, not two: a `write` whose delivery never happened is neither "escrito" nor a
   // deliberate hold, and collapsing it into either would hide the failure from the ops queue.
   let stamp;
@@ -419,6 +496,7 @@ async function runOutreachSweep({
   includePreviouslySwept = false,
   cadence = 'daily',
   mode = 'continuity',
+  source = WEEKLY_SOURCE,
   runOutreachTurn,
 } = {}) {
   if (typeof runOutreachTurn !== 'function') {
@@ -440,6 +518,12 @@ async function runOutreachSweep({
   if (!['continuity', 'monday_triage_recovery'].includes(mode)) {
     throw new Error('mode must be continuity or monday_triage_recovery');
   }
+  if (![WEEKLY_SOURCE, SCOPE_SOURCE].includes(source)) {
+    throw new Error('source must be weekly or patient_scope');
+  }
+  if (source === SCOPE_SOURCE && (mode !== 'continuity' || cadence !== 'daily' || !Array.isArray(patientScope))) {
+    throw new Error('the patient_scope source requires continuity mode, daily cadence and a patientScope');
+  }
 
   const localWeekday = moment.tz(now, DEFAULT_TIMEZONE).isoWeekday();
   if (mode === 'monday_triage_recovery' && localWeekday !== 1) {
@@ -457,7 +541,9 @@ async function runOutreachSweep({
   const rows = await airtableService.getRecordByFilter(
     Symptoms_ID, TABLE, 'TRUE()', mode === 'monday_triage_recovery' ? null : VIEW, Object.values(F), true,
   );
-  const { candidates, targetDays, weekday } = buildCandidates(rows || [], { now, cadence, mode });
+  const { candidates, targetDays, weekday } = source === SCOPE_SOURCE
+    ? { candidates: await loadScopeCandidates({ now, viewRows: rows || [], patientScope }), targetDays: [], weekday: localWeekday }
+    : buildCandidates(rows || [], { now, cadence, mode });
   if (cadence === 'legacy' && !targetDays.length) {
     logger.info('[outreachSweep] not a sweep day — nothing to do', { weekday });
     return { ran: false, weekday, reason: 'not_a_sweep_day', counts: {} };
@@ -495,7 +581,7 @@ async function runOutreachSweep({
   const weekdayLabel = moment.tz(now, DEFAULT_TIMEZONE).locale('es').format('dddd');
   const decisions = await mapWithConcurrency(admitted, concurrency, async (candidate) => {
     const brief = await enrichBrief(candidate);
-    if (!dryRun && !await claimCandidate({ candidate, weekdayLabel, dryRun })) {
+    if (!dryRun && !await claimCandidate({ candidate, weekdayLabel, dryRun, now })) {
       counts.rejected++;
       rejectedBy.claim_lost = (rejectedBy.claim_lost || 0) + 1;
       return { code: candidate.code, recordId: candidate.recordId, decision: 'skipped', holdReason: 'claim_lost' };
@@ -546,12 +632,13 @@ async function runOutreachSweep({
   });
 
   logger.info('[outreachSweep] complete', { dryRun, counts, rejectedBy });
-  return { ran: true, weekday, cadence, mode, targetDays, dryRun, counts, rejectedBy, decisions };
+  return { ran: true, weekday, cadence, mode, source, targetDays, dryRun, counts, rejectedBy, decisions };
 }
 
 module.exports = {
   runOutreachSweep,
   buildCandidates,
+  buildScopeCandidates,
   rejectionReason,
   priorSweepReason,
   TARGET_DAYS_BY_WEEKDAY,
@@ -562,5 +649,7 @@ module.exports = {
   mondayTriageStillPending,
   VIEW,
   F,
+  PATIENT_F,
   AUDIT,
+  sweepClaims,
 };

package/lib/index.d.ts

@@ -501,6 +501,7 @@ declare module '@peopl-health/nexus' {
     ran: boolean;
     weekday: number;
     mode?: 'continuity' | 'monday_triage_recovery';
+    source?: 'weekly' | 'patient_scope';
     targetDays?: string[];
     dryRun?: boolean;
     counts: Record<string, number>;
@@ -520,6 +521,8 @@ declare module '@peopl-health/nexus' {
     mode?: 'continuity' | 'monday_triage_recovery';
     /** daily: patients inactive for 7+ days. legacy: the Thursday/Saturday post-triage cohort (Mon/Tue and Wed/Thu triages). */
     cadence?: 'daily' | 'legacy';
+    /** weekly: the triage questionnaire view. patient_scope: the scoped patients outside that view; requires continuity, daily and a patientScope. */
+    source?: 'weekly' | 'patient_scope';
   }): Promise<OutreachSweepResult>;
 
   export const routes: any;

package/package.json

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