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

package/lib/clinical/providers/AnthropicProvider.js

@@ -1,60 +1,28 @@
 const { Anthropic } = require('@anthropic-ai/sdk');
 
-const { composePrompt } = require('../services/promptComposerService');
 const { retryWithBackoff } = require('../../utils/retryUtils');
 const { withTiming } = require('../../utils/tracingDecorator');
-const { isPlainObject, safeParse } = require('../../utils/jsonUtils');
 
 const { logger } = require('../../utils/logger');
 
-const runtimeConfig = require('../../config/runtimeConfig');
-
-const { BaseLLMProvider, CONVERSATION_CONTINUATION, DELIVERY_NUDGE, MAX_DELIVERY_NUDGES, TERMINAL_DELIVERY_TOOLS } = require('./BaseLLMProvider');
+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('[AnthropicProvider] Invalid MAX_FUNCTION_ROUNDS, falling back to default', { value: raw, default: DEFAULT_MAX_FUNCTION_ROUNDS });
-  }
-  return DEFAULT_MAX_FUNCTION_ROUNDS;
-}
-
-// Iterations that don't count against the tool budget: terminal-only delivery rounds (exempt at the toolRounds check) plus the loop's own end/break passes. Bounds the loop against a misbehaving model.
-const LOOP_ITERATION_HEADROOM = 3;
-const CACHE_TTLS = ['5m', '1h'];
-const DEFAULT_CACHE_TTL = '1h';
-const DEFAULT_THINKING_MODE = 'until_commit';
-// Turns that end the model's clinical reasoning for the turn; after one, until_commit stops thinking. Diverges from the oracle,
-// which excludes submitRoutingDecision because its palliative/emergency branches do more work post-routing. Nexus has no careplan
-// or palliative tools (registerClinicalTools.js) — submitRoutingDecision is the terminal routing checkpoint here, so it belongs.
-const TERMINAL_COMMIT_TOOLS = new Set(['submitRoutingDecision', 'reportMedicalEscalation', 'reportCrisis', 'reportUnresolvedRequestv2']);
+const DEFAULT_MAX_FUNCTION_ROUNDS = 5;
 
 class AnthropicProvider extends BaseLLMProvider {
   constructor(options = {}) {
     super(options);
-    const { apiKey, client, maxFunctionRounds, defaultModels = {} } = options;
+    const { apiKey, client, maxFunctionRounds = DEFAULT_MAX_FUNCTION_ROUNDS, defaultModels = {} } = options;
 
     if (!client && !apiKey) {
       throw new Error('AnthropicProvider requires an API key or a preconfigured client');
     }
 
     this.client = client || new Anthropic({ apiKey });
-    this.maxFunctionRounds = resolveMaxFunctionRounds(maxFunctionRounds);
-    const cacheTtl = runtimeConfig.get('ANTHROPIC_CACHE_TTL', DEFAULT_CACHE_TTL);
-    if (!CACHE_TTLS.includes(cacheTtl)) {
-      logger.warn('[AnthropicProvider] Invalid ANTHROPIC_CACHE_TTL, falling back to default', { cacheTtl, default: DEFAULT_CACHE_TTL });
-    }
-    this.cacheTtl = CACHE_TTLS.includes(cacheTtl) ? cacheTtl : DEFAULT_CACHE_TTL;
+    this.maxFunctionRounds = maxFunctionRounds;
     this.defaults = {
       maxOutputTokens: 400,
-      structuredModel: 'claude-haiku-4-5',
-      structuredMaxTokens: 2048,
       ...defaultModels,
     };
 
@@ -64,7 +32,7 @@ class AnthropicProvider extends BaseLLMProvider {
 
   async _invokeModel({
     instructions, input, toolSchemas = [], toolChoice = 'auto', followUpToolChoice = 'auto',
-    modelConfig, assistant, phiProcessor = null, trace = null, onFirstIteration = null
+    modelConfig, assistant, phiProcessor = null, trace = null
   }, options = {}) {
     const executeTools = options.toolExecutor || handleFunctionCalls;
     let totalRetries = 0;
@@ -73,48 +41,23 @@ class AnthropicProvider extends BaseLLMProvider {
     const accumulatedUsage = { input_tokens: 0, output_tokens: 0, total_tokens: 0 };
     const addUsage = (usage) => {
       if (!usage) return;
-      const inputTokens = (usage.input_tokens || 0) + (usage.cache_read_input_tokens || 0) + (usage.cache_creation_input_tokens || 0);
-      accumulatedUsage.input_tokens += inputTokens;
+      accumulatedUsage.input_tokens += usage.input_tokens || 0;
       accumulatedUsage.output_tokens += usage.output_tokens || 0;
-      accumulatedUsage.total_tokens += inputTokens + (usage.output_tokens || 0);
+      accumulatedUsage.total_tokens += (usage.input_tokens || 0) + (usage.output_tokens || 0);
     };
 
     const { system, messages } = this._toAnthropicMessages(instructions, input);
-    const apiCallConfig = { ...this._mapModelConfig(modelConfig) };
-    // Captured before prepThinking() starts toggling apiCallConfig.thinking per call, so both the per-iteration gate and the
-    // tool_choice coercion read the same preset value rather than whichever iteration's state happens to be current.
-    const baseThinking = apiCallConfig.thinking;
-    const thinkingEnabled = baseThinking?.type === 'enabled';
-    const initialChoice = this._mapToolChoice(toolChoice);
-    // Only a request that actually carried the forced choice was coerced; with zero tools tool_choice was never sent.
-    const toolChoiceCoerced = toolSchemas.length > 0 && thinkingEnabled && (initialChoice.type === 'tool' || initialChoice.type === 'any');
-    if (system) apiCallConfig.system = system;
+    const apiCallConfig = { ...this._mapModelConfig(modelConfig), system };
     if (toolSchemas.length > 0) {
       apiCallConfig.tools = this._mapTools(toolSchemas);
-      apiCallConfig.tool_choice = this._resolveToolChoice(toolChoice, thinkingEnabled);
+      apiCallConfig.tool_choice = this._mapToolChoice(toolChoice);
     }
 
-    const thinkingMode = modelConfig?.thinking_mode || DEFAULT_THINKING_MODE;
-    let modelCallNum = 0;
-    let terminalCommitSeen = false;
-    const prepThinking = () => {
-      modelCallNum += 1;
-      if (baseThinking && this._thinkingForIter(modelCallNum, thinkingMode, terminalCommitSeen)) apiCallConfig.thinking = baseThinking;
-      else delete apiCallConfig.thinking;
-    };
-
-    const betas = Array.isArray(modelConfig?.betas) ? modelConfig.betas.filter(b => typeof b === 'string' && b.length) : [];
-    const makeAPICall = (msgs) => {
-      // interleaved-thinking requires thinking enabled on the call; drop it on iters the gate turned thinking off.
-      const active = apiCallConfig.thinking ? betas : betas.filter(b => !b.startsWith('interleaved-thinking'));
-      const requestOptions = active.length ? { headers: { 'anthropic-beta': active.join(',') } } : undefined;
-      return retryWithBackoff(
-        () => this.client.messages.create({ messages: msgs, ...apiCallConfig }, requestOptions),
-        { providerName: this.constructor.name }
-      );
-    };
+    const makeAPICall = (msgs) => retryWithBackoff(
+      () => this.client.messages.create({ messages: msgs, ...apiCallConfig }),
+      { providerName: this.constructor.name }
+    );
 
-    prepThinking();
     const { result: { result: response, retries }, durationMs } = await withTiming(() => makeAPICall(messages));
     totalRetries += retries;
     addUsage(response.usage);
@@ -122,78 +65,12 @@ class AnthropicProvider extends BaseLLMProvider {
     let finalResponse = response;
     const currentMessages = [...messages];
 
-    // Coercion is silent-by-default; the event that matters is the model then *declining* the forced tool under 'auto'.
-    if (toolChoiceCoerced) {
-      const toolUses = (response.content || []).filter(block => block.type === 'tool_use');
-      // A named force ('tool') is satisfied only by THAT tool; 'any'/'required' by any tool_use. Partial compliance
-      // (e.g. DeliverPatientMessage fires but the forced reportUnresolvedRequestv2 does not) must count as skipped.
-      const firedTool = initialChoice.type === 'tool'
-        ? toolUses.some(block => block.name === initialChoice.name)
-        : toolUses.length > 0;
-      trace?.setSignals?.({ toolChoiceCoerced: true, forcedToolSkipped: !firedTool });
-      if (!firedTool) {
-        logger.warn('[AnthropicProvider] Forced tool skipped after coercion to auto under thinking', { requested: initialChoice.type, tool: initialChoice.name || null });
-      }
-    }
-
-    let bridgeNote = null;
-    if (onFirstIteration) {
-      const narrationText = (response.content || [])
-        .filter(block => block.type === 'text')
-        .map(block => block.text || '')
-        .join(' ')
-        .trim();
-      const hasToolCalls = Boolean(assistant) && toolSchemas.length > 0
-        && response.stop_reason === 'tool_use'
-        && (response.content || []).some(block => block.type === 'tool_use');
-      try {
-        const decision = onFirstIteration({ narrationText, hasToolCalls });
-        if (decision?.sent && decision.dedupNote) bridgeNote = decision.dedupNote;
-      } catch (err) {
-        logger.warn('[AnthropicProvider] bridge callback failed', { error: err.message });
-      }
-    }
-
     if (assistant && toolSchemas.length > 0) {
-      // Defensive: followUpToolChoice is the run-level value (already 'auto'/'none' on the classifier path); a forced value only
-      // reaches here from a caller that sets one at run level (e.g. EvalProvider).
-      apiCallConfig.tool_choice = this._resolveToolChoice(followUpToolChoice, thinkingEnabled);
-      const canDeliver = toolSchemas.some(s => TERMINAL_DELIVERY_TOOLS.has(s.function?.name));
-
-      let toolRounds = 0;
-      let deliveryNudges = 0;
-      const maxIterations = this.maxFunctionRounds + MAX_DELIVERY_NUDGES + LOOP_ITERATION_HEADROOM;
-      for (let iteration = 1; iteration <= maxIterations; iteration++) {
-        const content = finalResponse.content || [];
-        const toolUses = content.filter(block => block.type === 'tool_use');
-        const ended = finalResponse.stop_reason !== 'tool_use' || !toolUses.length;
-        const terminalOnly = toolUses.length > 0 && toolUses.every(block => TERMINAL_DELIVERY_TOOLS.has(block.name));
-        const budgetSpent = toolRounds >= this.maxFunctionRounds && !terminalOnly;
-
-        // Nudge on an actual delivery, not narration: a text block is not a patient message, so a turn ending in
-        // narration without DeliverPatientMessage still nudges. Rides on the last user turn (empty completions carry no content to echo).
-        if ((ended || budgetSpent) && canDeliver && !this._deliveryCommitted(allToolsExecuted) && deliveryNudges < MAX_DELIVERY_NUDGES) {
-          const lastUserTurn = currentMessages[currentMessages.length - 1];
-          if (lastUserTurn?.role === 'user') {
-            deliveryNudges++;
-            logger.warn('[AnthropicProvider] Turn will not deliver — nudging DeliverPatientMessage', { deliveryNudges, ended, budgetSpent });
-            const turnContent = Array.isArray(lastUserTurn.content)
-              ? lastUserTurn.content
-              : [{ type: 'text', text: String(lastUserTurn.content ?? '') }];
-            lastUserTurn.content = [...turnContent, { type: 'text', text: DELIVERY_NUDGE }];
-            // The nudge is a model call like any other: gate thinking on it so the per-iteration counter stays honest.
-            prepThinking();
-            const { result: { result: nudged, retries: nudgeRetries }, durationMs: nudgeDurationMs } = await withTiming(() => makeAPICall(currentMessages));
-            totalRetries += nudgeRetries;
-            addUsage(nudged.usage);
-            producingIteration = trace?.addIteration({ response: nudged, durationMs: nudgeDurationMs, apiCallConfig }) || null;
-            finalResponse = nudged;
-            continue;
-          }
-        }
+      apiCallConfig.tool_choice = this._mapToolChoice(followUpToolChoice);
 
-        if (ended || budgetSpent) break;
-        if (!terminalOnly) toolRounds++;
+      for (let round = 1; round <= this.maxFunctionRounds; round++) {
+        const toolUses = (finalResponse.content || []).filter(block => block.type === 'tool_use');
+        if (finalResponse.stop_reason !== 'tool_use' || !toolUses.length) break;
 
         const functionCalls = toolUses.map(block => ({
           name: block.name,
@@ -203,150 +80,43 @@ class AnthropicProvider extends BaseLLMProvider {
         allToolCalls.push(...toolUses.map(block => ({ name: block.name, arguments: block.input ?? {}, call_id: block.id })));
         const { outputs, toolsExecuted } = await executeTools(functionCalls, assistant, phiProcessor, producingIteration);
 
-        const userContent = outputs.map(o => ({ type: 'tool_result', tool_use_id: o.call_id, content: o.output }));
-        if (bridgeNote) {
-          userContent.push({ type: 'text', text: bridgeNote });
-          bridgeNote = null;
-        }
         currentMessages.push(
           { role: 'assistant', content: finalResponse.content },
-          { role: 'user', content: userContent }
+          { role: 'user', content: outputs.map(o => ({ type: 'tool_result', tool_use_id: o.call_id, content: o.output })) }
         );
         allToolsExecuted.push(...toolsExecuted);
-        if (toolsExecuted.some(t => TERMINAL_COMMIT_TOOLS.has(t?.tool_name))) terminalCommitSeen = true;
 
-        prepThinking();
         const { result: { result: followUp, retries: followUpRetries }, durationMs: followUpDurationMs } = await withTiming(() => makeAPICall(currentMessages));
         totalRetries += followUpRetries;
         addUsage(followUp.usage);
         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.
-      const pendingTools = (finalResponse.content || []).filter(block => block.type === 'tool_use');
-      if (finalResponse.stop_reason === 'tool_use' && pendingTools.length) {
-        logger.warn('[AnthropicProvider] Tool-iteration budget exhausted with pending tool calls', { maxFunctionRounds: this.maxFunctionRounds, pending: pendingTools.map(b => b.name) });
-        trace?.setSignals?.({ toolBudgetExhausted: true });
-      }
     }
 
     return { response: this._normalizeResponse(finalResponse), toolCalls: allToolCalls, toolsExecuted: allToolsExecuted, retries: totalRetries, usage: accumulatedUsage };
   }
 
-  async runStructured({ promptId = null, presetId = null, instructions = null, variables = null, input = [], text = null, model = null } = {}) {
-    let modelConfig = {};
-    let resolvedInstructions = instructions;
-    if (promptId || presetId) {
-      const composed = await composePrompt({ promptId, presetId, variables });
-      modelConfig = composed.modelConfig || {};
-      if (!resolvedInstructions) resolvedInstructions = composed.resolvedPrompt;
-    }
-
-    const { system, messages } = this._toAnthropicMessages(resolvedInstructions, input);
-
-    const apiConfig = {
-      model: model || (modelConfig.model && modelConfig.model.replace(/^anthropic\//, '')) || this.defaults.structuredModel,
-      max_tokens: modelConfig.max_output_tokens || this.defaults.structuredMaxTokens,
-    };
-    if (system) apiConfig.system = system;
-
-    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');
-      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 } = await retryWithBackoff(
-      () => this.client.messages.create({ messages, ...apiConfig }),
-      { providerName: this.constructor.name },
-    );
-    return tool ? this._normalizeStructured(result, tool) : this._normalizeResponse(result);
-  }
-
   _toAnthropicMessages(instructions, input) {
-    // Caching is a prefix match, so one block would let any per-turn byte invalidate the prompt and
-    // the tool schemas ahead of it. Split them: stable content is cached, runtime content is not.
-    const stableParts = [];
-    if (instructions) stableParts.push(instructions);
-    const runtimeParts = [];
-
-    const outputsByCallId = new Map();
-    for (const item of input || []) {
-      if (item.type === 'function_call_output') outputsByCallId.set(item.call_id, item.output);
-    }
+    const systemParts = [];
+    if (instructions) systemParts.push(instructions);
 
     const messages = [];
-    let pendingUses = [];
-    let pendingResults = [];
-    const flushTools = () => {
-      if (!pendingUses.length) return;
-      messages.push({ role: 'assistant', content: pendingUses });
-      messages.push({ role: 'user', content: pendingResults });
-      pendingUses = [];
-      pendingResults = [];
-    };
-
     for (const item of input || []) {
       const type = item.type || 'message';
-      if (type === 'function_call') {
-        if (!outputsByCallId.has(item.call_id)) continue;
-        pendingUses.push({ type: 'tool_use', id: item.call_id, name: item.name, input: this._toToolInput(item.arguments) });
-        pendingResults.push({ type: 'tool_result', tool_use_id: item.call_id, content: this._toToolContent(outputsByCallId.get(item.call_id)) });
+      if (type !== 'message') {
+        logger.debug('[AnthropicProvider] Skipping non-message input item', { type });
         continue;
       }
-      if (type === 'function_call_output') continue;
-      flushTools();
       const content = item.content;
-      // The role picks the side: 'system' is stable (composerService ships skill prompts this way),
-      // 'developer' is per-turn.
-      if (item.role === 'system') {
-        if (content) stableParts.push(content);
-        continue;
-      }
-      if (item.role === 'developer') {
-        if (content) runtimeParts.push(content);
+      if (item.role === 'developer' || item.role === 'system') {
+        if (content) systemParts.push(content);
         continue;
       }
       messages.push({ role: item.role === 'assistant' ? 'assistant' : 'user', content });
     }
-    flushTools();
-
-    if (!messages.length || messages[messages.length - 1].role === 'assistant') {
-      messages.push({ role: 'user', content: CONVERSATION_CONTINUATION });
-    }
-
-    const system = [];
-    if (stableParts.length) {
-      system.push({
-        type: 'text',
-        text: stableParts.join('\n\n'),
-        cache_control: { type: 'ephemeral', ttl: this.cacheTtl },
-      });
-    }
-    // Deliberately no cache_control: caching a prefix that changes every turn only pays write costs.
-    if (runtimeParts.length) {
-      system.push({ type: 'text', text: runtimeParts.join('\n\n') });
-    }
 
-    return { system: system.length ? system : null, messages };
-  }
-
-  _toToolInput(args) {
-    if (isPlainObject(args)) return args;
-    const parsed = safeParse(args, null);
-    if (isPlainObject(parsed)) return parsed;
-    logger.warn('[AnthropicProvider] Unusable tool arguments in history, sending empty input');
-    return {};
-  }
-
-  _toToolContent(output) {
-    return typeof output === 'string' ? output : JSON.stringify(output ?? '');
+    return { system: systemParts.join('\n\n'), messages };
   }
 
   _mapModelConfig(modelConfig) {
@@ -358,8 +128,6 @@ class AnthropicProvider extends BaseLLMProvider {
     delete mapped.text;
     delete mapped.reasoning;
     delete mapped.max_output_tokens;
-    delete mapped.betas;
-    delete mapped.thinking_mode;
     if (mapped.max_tokens == null) mapped.max_tokens = this.defaults.maxOutputTokens;
     return mapped;
   }
@@ -367,35 +135,16 @@ class AnthropicProvider extends BaseLLMProvider {
   _mapTools(toolSchemas) {
     return toolSchemas.map(schema => {
       const fn = schema.function || schema;
-      // The clinical tool set compiles as one grammar per request; strict on all of them
-      // exceeds Anthropic's complexity limit. runStructured keeps strict — single schema.
-      return {
+      const tool = {
         name: fn.name,
         description: fn.description,
         input_schema: fn.parameters || { type: 'object', properties: {} },
       };
+      if (fn.strict !== undefined) tool.strict = fn.strict;
+      return tool;
     });
   }
 
-  _thinkingForIter(iterationNum, mode, terminalCommitSeen) {
-    if (mode === 'always') return true;
-    if (mode === 'first_iter') return iterationNum === 1;
-    return iterationNum === 1 || !terminalCommitSeen;
-  }
-
-  // Anthropic rejects a forced tool_choice ('tool'/'any') while extended thinking is enabled, so under thinking a forced
-  // choice is coerced to 'auto'. This deliberately prefers thinking over the tool guarantee: the model is already strongly
-  // prompted to call the tool. Adaptive thinking ({type:'adaptive'}) is intentionally NOT coerced — it is accepted with a
-  // forced choice on the first-party API (only Bedrock requires thinking off), so the guard fires on 'enabled' only.
-  _resolveToolChoice(toolChoice, thinkingEnabled) {
-    const mapped = this._mapToolChoice(toolChoice);
-    if (thinkingEnabled && (mapped.type === 'tool' || mapped.type === 'any')) {
-      logger.debug('[AnthropicProvider] Forced tool_choice coerced to auto under extended thinking', { requested: mapped.type, tool: mapped.name || null });
-      return { type: 'auto' };
-    }
-    return mapped;
-  }
-
   _mapToolChoice(toolChoice) {
     if (!toolChoice || toolChoice === 'auto') return { type: 'auto' };
     if (toolChoice === 'none') return { type: 'none' };
@@ -411,16 +160,6 @@ class AnthropicProvider extends BaseLLMProvider {
       .map(block => block.text || '')
       .join('')
       .trim();
-    return this._envelope(response, outputText);
-  }
-
-  _normalizeStructured(response, tool) {
-    const toolUse = (response.content || []).find(block => block.type === 'tool_use' && block.name === tool.name);
-    const outputText = toolUse ? JSON.stringify(toolUse.input ?? {}) : '';
-    return this._envelope(response, outputText);
-  }
-
-  _envelope(response, outputText) {
     const output = outputText
       ? [{ type: 'message', role: 'assistant', content: [{ type: 'output_text', text: outputText }] }]
       : [];
@@ -432,12 +171,11 @@ class AnthropicProvider extends BaseLLMProvider {
       }
       : undefined;
 
-    const statusByStopReason = { refusal: 'refused', max_tokens: 'incomplete' };
     return {
       id: response.id,
       object: 'response',
       model: response.model,
-      status: statusByStopReason[response.stop_reason] || 'completed',
+      status: response.stop_reason === 'refusal' ? 'refused' : 'completed',
       stop_reason: response.stop_reason,
       output,
       output_text: outputText,