@peopl-health/nexus 4.7.0-dev.0 → 4.7.0-dev.1

package/lib/clinical/providers/OpenRouterProvider.js

@@ -1,6 +1,11 @@
 const { OpenAI } = require('openai');
 
+const { retryWithBackoff } = require('../../utils/retryUtils');
+const { withTiming } = require('../../utils/tracingDecorator');
+const { safeParse } = require('../../utils/jsonUtils');
+
 const { OpenAIResponsesProvider } = require('./OpenAIResponsesProvider');
+const { handleFunctionCalls } = require('./OpenAIResponsesProviderTools');
 
 const OPENROUTER_BASE_URL = 'https://openrouter.ai/api/v1';
 const DEFAULT_MODEL_VENDOR = 'openai';
@@ -30,9 +35,146 @@ class OpenRouterProvider extends OpenAIResponsesProvider {
     this.transcriptionClient = null;
   }
 
+  async _invokeModel({
+    instructions, input, toolSchemas = [], toolChoice = 'auto', followUpToolChoice = 'auto',
+    modelConfig, assistant, phiProcessor = null, trace = null
+  }, options = {}) {
+    const executeTools = options.toolExecutor || handleFunctionCalls;
+    let totalRetries = 0;
+    const allToolsExecuted = [];
+    const allToolCalls = [];
+    const accumulatedUsage = { input_tokens: 0, output_tokens: 0, total_tokens: 0 };
+    const addUsage = (usage) => {
+      if (!usage) return;
+      accumulatedUsage.input_tokens += usage.prompt_tokens || 0;
+      accumulatedUsage.output_tokens += usage.completion_tokens || 0;
+      accumulatedUsage.total_tokens += usage.total_tokens || 0;
+    };
+
+    const messages = this._toChatMessages(instructions, input);
+    const apiCallConfig = { ...this._mapModelConfig(modelConfig) };
+    if (toolSchemas.length > 0) {
+      apiCallConfig.tools = toolSchemas;
+      apiCallConfig.tool_choice = toolChoice;
+    }
+
+    const makeAPICall = (msgs) => retryWithBackoff(
+      () => this.client.chat.completions.create({ messages: msgs, ...apiCallConfig }),
+      { providerName: this.constructor.name }
+    );
+
+    const { result: { result: response, retries }, durationMs } = await withTiming(() => makeAPICall(messages));
+    totalRetries += retries;
+    addUsage(response.usage);
+    let producingIteration = trace?.addIteration({ response, durationMs, apiCallConfig }) || null;
+    let finalResponse = response;
+    const currentMessages = [...messages];
+
+    if (assistant && toolSchemas.length > 0) {
+      apiCallConfig.tool_choice = followUpToolChoice;
+
+      for (let round = 1; round <= this.maxFunctionRounds; round++) {
+        const message = finalResponse.choices?.[0]?.message;
+        const toolCalls = message?.tool_calls || [];
+        if (!toolCalls.length) break;
+
+        const functionCalls = toolCalls.map(tc => ({
+          name: tc.function.name,
+          arguments: tc.function.arguments,
+          call_id: tc.id,
+        }));
+        allToolCalls.push(...toolCalls.map(tc => ({ name: tc.function.name, arguments: safeParse(tc.function.arguments), call_id: tc.id })));
+        const { outputs, toolsExecuted } = await executeTools(functionCalls, assistant, phiProcessor, producingIteration);
+
+        currentMessages.push(
+          message,
+          ...outputs.map(o => ({ role: 'tool', tool_call_id: o.call_id, content: this._toToolContent(o.output) }))
+        );
+        allToolsExecuted.push(...toolsExecuted);
+
+        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;
+      }
+    }
+
+    return { response: this._normalizeResponse(finalResponse), toolCalls: allToolCalls, toolsExecuted: allToolsExecuted, retries: totalRetries, usage: accumulatedUsage };
+  }
+
+  _toChatMessages(instructions, input) {
+    const systemParts = [];
+    if (instructions) systemParts.push(instructions);
+
+    const outputsByCallId = new Map();
+    for (const item of input || []) {
+      if (item.type === 'function_call_output') outputsByCallId.set(item.call_id, item.output);
+    }
+
+    const messages = [];
+    for (const item of input || []) {
+      const type = item.type || 'message';
+      if (type === 'function_call') {
+        if (!outputsByCallId.has(item.call_id)) continue;
+        messages.push({
+          role: 'assistant',
+          content: null,
+          tool_calls: [{ id: item.call_id, type: 'function', function: { name: item.name, arguments: item.arguments || '{}' } }],
+        });
+        messages.push({ role: 'tool', tool_call_id: item.call_id, content: this._toToolContent(outputsByCallId.get(item.call_id)) });
+        continue;
+      }
+      if (type === 'function_call_output') continue;
+      const content = item.content;
+      if (item.role === 'developer' || item.role === 'system') {
+        if (content) systemParts.push(content);
+        continue;
+      }
+      messages.push({ role: item.role === 'assistant' ? 'assistant' : 'user', content });
+    }
+
+    const system = systemParts.join('\n\n');
+    return system ? [{ role: 'system', content: system }, ...messages] : messages;
+  }
+
+  _toToolContent(output) {
+    return typeof output === 'string' ? output : JSON.stringify(output ?? '');
+  }
+
+  _normalizeResponse(response) {
+    const choice = response.choices?.[0];
+    const outputText = (choice?.message?.content || '').trim();
+    const output = outputText
+      ? [{ type: 'message', role: 'assistant', content: [{ type: 'output_text', text: outputText }] }]
+      : [];
+    const usage = response.usage
+      ? {
+        input_tokens: response.usage.prompt_tokens || 0,
+        output_tokens: response.usage.completion_tokens || 0,
+        total_tokens: response.usage.total_tokens || 0,
+      }
+      : undefined;
+
+    return {
+      id: response.id,
+      object: 'response',
+      model: response.model,
+      status: choice?.finish_reason === 'content_filter' ? 'refused' : 'completed',
+      stop_reason: choice?.finish_reason,
+      output,
+      output_text: outputText,
+      usage,
+      raw: response,
+    };
+  }
+
   _mapModelConfig(modelConfig) {
-    const mapped = { ...modelConfig };
+    const mapped = { ...(modelConfig || {}) };
+    if (mapped.max_tokens == null && mapped.max_output_tokens != null) mapped.max_tokens = mapped.max_output_tokens;
     delete mapped.store;
+    delete mapped.text;
+    delete mapped.max_output_tokens;
     mapped.model = this._toOpenRouterModel(mapped.model || this.defaults.responseModel);
     return mapped;
   }

package/package.json

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