@peopl-health/nexus 2.2.8 → 2.2.9

package/lib/assistants/BaseAssistant.js

@@ -140,6 +140,10 @@ class BaseAssistant {
       }
     };
 
+    if (definition.strict !== undefined) {
+      toolSchema.function.strict = definition.strict;
+    }
+
     this.tools.set(name, {
       schema: toolSchema,
       execute: executor

package/lib/providers/OpenAIResponsesProvider.js

@@ -1,5 +1,10 @@
 const { OpenAI } = require('openai');
 const { retryWithBackoff } = require('../utils/retryHelper');
+const {
+  handlePendingFunctionCalls: handlePendingFunctionCallsUtil,
+  handleRequiresAction: handleRequiresActionUtil,
+  transformToolsForResponsesAPI: transformToolsForResponsesAPIUtil
+} = require('./OpenAIResponsesProviderTools');
 
 const CONVERSATION_PREFIX = 'conv_';
 const RESPONSE_PREFIX = 'resp_';
@@ -265,11 +270,29 @@ class OpenAIResponsesProvider {
     truncationStrategy,
     tools = [],
     model,
+    assistant,
   } = {}) {
     try {
       const id = this._ensurethreadId(threadId);
       const messages = this._responseInput(additionalMessages) || [];
 
+      // Check for pending function calls in the conversation before creating a new response
+      if (assistant && toolOutputs.length === 0) {
+        try {
+          const conversationMessages = await this.listMessages({ threadId: id, order: 'desc', limit: 50 });
+          const items = conversationMessages?.data || [];
+          const pendingOutputs = await handlePendingFunctionCallsUtil(assistant, items);
+          if (pendingOutputs.length > 0) {
+            toolOutputs = pendingOutputs;
+          }
+        } catch (error) {
+          console.warn('[OpenAIResponsesProvider] Error checking for pending function calls:', error?.message);
+        }
+      }
+
+      // Transform tools to Responses API format (name at top level, not nested in function)
+      const transformedTools = transformToolsForResponsesAPIUtil(this.variant, tools);
+
       const payload = this._cleanObject({
         conversation: id,
         prompt: { id: assistantId },
@@ -281,7 +304,7 @@ class OpenAIResponsesProvider {
         temperature,
         max_output_tokens: maxOutputTokens,
         truncation_strategy: truncationStrategy,
-        tools: Array.isArray(tools) && tools.length ? tools : undefined,
+        tools: transformedTools,
       });
 
       console.log('payload', payload);
@@ -390,34 +413,7 @@ class OpenAIResponsesProvider {
   }
 
   async handleRequiresAction(assistant, run, threadId) {
-    const functionCalls = run.output?.filter(item => item.type === 'function_call') || [];
-    if (functionCalls.length === 0) {
-      return [];
-    }
-
-    const outputs = [];
-
-    for (const call of functionCalls) {
-      try {
-        const name = call.name;
-        const args = call.arguments ? JSON.parse(call.arguments) : {};
-        const result = await assistant.executeTool(name, args);
-        outputs.push({
-          type: 'function_call_output',
-          call_id: call.call_id,
-          output: typeof result === 'string' ? result : JSON.stringify(result)
-        });
-      } catch (error) {
-        console.error('[OpenAIResponsesProvider] Tool execution failed', error);
-        outputs.push({
-          type: 'function_call_output',
-          call_id: call.call_id,
-          output: JSON.stringify({ success: false, error: error?.message || 'Tool execution failed' })
-        });
-      }
-    }
-
-    return outputs;
+    return await handleRequiresActionUtil(assistant, run);
   }
 
   async checkRunStatus(assistant, thread_id, run_id, retryCount = 0, maxRetries = DEFAULT_MAX_RETRIES, actionHandled = false) {
@@ -425,33 +421,62 @@ class OpenAIResponsesProvider {
       let run = await this.getRun({ threadId: thread_id, runId: run_id });
       console.log(`Status: ${run.status} ${thread_id} ${run_id} (attempt ${retryCount + 1})`);
 
+      if (run.status === 'completed') {
+        return {run, completed: true};
+      }
+
+      if (run.status === 'failed' || run.status === 'cancelled' || run.status === 'expired') {
+        return {run, completed: false};
+      }
+
       const needsFunctionCall = run.output?.some(item => item.type === 'function_call');
       if (needsFunctionCall && !actionHandled) {
         if (retryCount >= maxRetries) {
+          console.warn('[OpenAIResponsesProvider] Max retries reached while handling function calls');
           return {run, completed: false};
         }
 
-        const outputs = await this.handleRequiresAction(assistant, run, thread_id);
+        const outputs = await handleRequiresActionUtil(assistant, run);
         console.log('[OpenAIResponsesProvider] Function call outputs:', outputs);
         
         if (outputs.length > 0) {
-          run = await this.runConversation({
-            threadId: thread_id,
-            assistantId: assistant.assistantId || assistant.promptId,
-            toolOutputs: outputs
-          });
-          
-          return this.checkRunStatus(assistant, thread_id, run.id, retryCount + 1, maxRetries, true);
+          try {
+            await this.submitToolOutputs({
+              threadId: thread_id,
+              runId: run_id,
+              toolOutputs: outputs
+            });
+            
+            await new Promise(resolve => setTimeout(resolve, 1000));
+            
+            return this.checkRunStatus(assistant, thread_id, run_id, retryCount + 1, maxRetries, true);
+          } catch (submitError) {
+            console.error('[OpenAIResponsesProvider] Error submitting tool outputs:', submitError);
+            if (retryCount < maxRetries) {
+              await new Promise(resolve => setTimeout(resolve, 2000));
+              return this.checkRunStatus(assistant, thread_id, run_id, retryCount + 1, maxRetries, false);
+            }
+            return {run, completed: false};
+          }
+        } else {
+          console.warn('[OpenAIResponsesProvider] Function calls detected but no outputs generated');
+          return {run, completed: false};
         }
       }
 
-      return {run, completed: true};
+      if (retryCount < maxRetries) {
+        await new Promise(resolve => setTimeout(resolve, 1000));
+        return this.checkRunStatus(assistant, thread_id, run_id, retryCount + 1, maxRetries, actionHandled);
+      }
+
+      return {run, completed: false};
     } catch (error) {
-      console.error('Error checking run status:', error);
+      console.error('[OpenAIResponsesProvider] Error checking run status:', error);
       return {run: null, completed: false};
     }
   }
 
+
   /**
    * Internal helpers
    */

package/lib/providers/OpenAIResponsesProviderTools.js

@@ -0,0 +1,113 @@
+/**
+ * Tool and function call handling utilities for OpenAIResponsesProvider
+ */
+
+/**
+ * Execute a function call and return the output format
+ * @param {Object} assistant - The assistant instance with executeTool method
+ * @param {Object} call - The function call object with name, arguments, and call_id
+ * @returns {Promise<Object>} Function call output in Responses API format
+ */
+async function executeFunctionCall(assistant, call) {
+  try {
+    const name = call.name;
+    const args = call.arguments ? JSON.parse(call.arguments) : {};
+    const result = await assistant.executeTool(name, args);
+    return {
+      type: 'function_call_output',
+      call_id: call.call_id,
+      output: typeof result === 'string' ? result : JSON.stringify(result)
+    };
+  } catch (error) {
+    console.error('[OpenAIResponsesProvider] Tool execution failed', error);
+    return {
+      type: 'function_call_output',
+      call_id: call.call_id,
+      output: JSON.stringify({ success: false, error: error?.message || 'Tool execution failed' })
+    };
+  }
+}
+
+/**
+ * Handle pending function calls from conversation items
+ * @param {Object} assistant - The assistant instance with executeTool method
+ * @param {Array} conversationItems - Array of conversation items
+ * @returns {Promise<Array>} Array of function call outputs
+ */
+async function handlePendingFunctionCalls(assistant, conversationItems) {
+  const pendingFunctionCalls = conversationItems.filter(item => item.type === 'function_call');
+  const functionOutputs = conversationItems.filter(item => item.type === 'function_call_output');
+  
+  const orphanedCalls = pendingFunctionCalls.filter(call => 
+    !functionOutputs.some(output => output.call_id === call.call_id)
+  );
+  
+  if (orphanedCalls.length === 0) {
+    return [];
+  }
+
+  console.log(`[OpenAIResponsesProvider] Found ${orphanedCalls.length} pending function calls, handling them...`);
+  const outputs = [];
+  for (const call of orphanedCalls) {
+    outputs.push(await executeFunctionCall(assistant, call));
+  }
+  return outputs;
+}
+
+/**
+ * Handle function calls from a run output
+ * @param {Object} assistant - The assistant instance with executeTool method
+ * @param {Object} run - The run object with output array
+ * @returns {Promise<Array>} Array of function call outputs
+ */
+async function handleRequiresAction(assistant, run) {
+  const functionCalls = run.output?.filter(item => item.type === 'function_call') || [];
+  if (functionCalls.length === 0) {
+    return [];
+  }
+
+  const outputs = [];
+  for (const call of functionCalls) {
+    outputs.push(await executeFunctionCall(assistant, call));
+  }
+
+  return outputs;
+}
+
+/**
+ * Transform tools from Assistants API format to Responses API format
+ * @param {string} variant - The API variant ('responses' or 'assistants')
+ * @param {Array} tools - Array of tool definitions
+ * @returns {Array|undefined} Transformed tools or undefined if empty
+ */
+function transformToolsForResponsesAPI(variant, tools) {
+  if (variant !== 'responses' || !Array.isArray(tools) || tools.length === 0) {
+    return Array.isArray(tools) && tools.length > 0 ? tools : undefined;
+  }
+
+  return tools.map(tool => {
+    // If tool is in Assistants API format (type: 'function', function: {...})
+    if (tool.type === 'function' && tool.function) {
+      const transformed = {
+        name: tool.function.name,
+        type: 'function',
+        description: tool.function.description,
+        parameters: tool.function.parameters
+      };
+      if (tool.function.strict !== undefined) {
+        transformed.strict = tool.function.strict;
+      }
+      return transformed;
+    }
+    // If already in Responses API format, return as-is
+    return tool;
+  });
+}
+
+module.exports = {
+  executeFunctionCall,
+  handlePendingFunctionCalls,
+  handleRequiresAction,
+  transformToolsForResponsesAPI
+};
+

package/lib/services/assistantService.js

@@ -41,12 +41,22 @@ const runAssistantAndWait = async ({
   }
 
   const provider = createProvider({ variant: process.env.VARIANT || 'assistants' });
-  const { polling, ...conversationConfig } = runConfig || {};
+  const { polling, tools: configTools, ...conversationConfig } = runConfig || {};
+  const variant = provider.getVariant ? provider.getVariant() : (process.env.VARIANT || 'assistants');
+
+  // Get tool schemas from assistant if available, fallback to config tools
+  const tools = assistant.getToolSchemas ? assistant.getToolSchemas() : (configTools || []);
+
+  // Only pass assistant for Responses API (needed to handle pending function calls)
+  const runConfigWithAssistant = variant === 'responses'
+    ? { ...conversationConfig, assistant }
+    : conversationConfig;
 
   let run = await provider.runConversation({
     threadId: thread.getConversationId(),
     assistantId: thread.getAssistantId(),
-    ...conversationConfig,
+    tools: tools.length > 0 ? tools : undefined,
+    ...runConfigWithAssistant,
   });
 
   const filter = thread.code ? { code: thread.code, active: true } : null;

package/package.json

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