@peopl-health/nexus 2.5.5-message-tracking → 2.5.6

package/lib/providers/OpenAIResponsesProvider.js

@@ -1,15 +1,15 @@
 const { OpenAI } = require('openai');
+const { Thread } = require('../models/threadModel');
 const { retryWithBackoff } = require('../utils/retryHelper');
 const {
+  handleFunctionCalls: handleFunctionCallsUtil,
   handlePendingFunctionCalls: handlePendingFunctionCallsUtil,
-  handleRequiresAction: handleRequiresActionUtil,
   transformToolsForResponsesAPI: transformToolsForResponsesAPIUtil
 } = require('./OpenAIResponsesProviderTools');
 const { logger } = require('../utils/logger');
 
 const CONVERSATION_PREFIX = 'conv_';
 const RESPONSE_PREFIX = 'resp_';
-const DEFAULT_MAX_RETRIES = parseInt(process.env.MAX_RETRIES || '10', 10);
 const MAX_ITEMS_ON_CREATE = 20;
 const MAX_ITEMS_PER_BATCH = 20;
 const DEFAULT_MAX_HISTORICAL_MESSAGES = parseInt(process.env.MAX_HISTORICAL_MESSAGES || '50', 10);
@@ -55,26 +55,7 @@ class OpenAIResponsesProvider {
   }
 
   /**
-   * Retry helper wrapper that uses shared retry logic
-   * @private
-   */
-  async _retryWithBackoff(operation, options = {}) {
-    return retryWithBackoff(operation, {
-      ...options,
-      providerName: PROVIDER_NAME,
-    });
-  }
-
-  /**
-   * @deprecated Use _retryWithBackoff instead
-   * Kept for backward compatibility
-   */
-  async _retryWithRateLimit(operation, maxRetries = 3, retryCount = 0) {
-    return this._retryWithBackoff(operation, { maxRetries, retryCount });
-  }
-
-  /**
-   * Conversations helpers
+   * Create Conversation
    */
   async createConversation({ metadata, messages = [], toolResources } = {}) {
     const messagesToProcess = messages.length > DEFAULT_MAX_HISTORICAL_MESSAGES 
@@ -85,52 +66,16 @@ class OpenAIResponsesProvider {
       logger.warn(`[OpenAIResponsesProvider] Capped ${messages.length} → ${DEFAULT_MAX_HISTORICAL_MESSAGES} messages`);
     }
     
-    const allItems = this._conversationItems(messagesToProcess);
-    const totalItems = allItems.length;
-    
-    // Create empty conversation if no messages
-    if (totalItems === 0) {
-      const payload = this._cleanObject({
-        metadata,
-        tool_resources: toolResources,
-      });
-      
-      return this._retryWithRateLimit(async () => {
-        if (this.conversations && typeof this.conversations.create === 'function') {
-          return await this.conversations.create(payload);
-        }
-        return await this._post('/conversations', payload);
-      });
-    }
-    
-    // Split items: first batch for initial creation, rest to add in batches
+    const allItems = this._convertItemsToApiFormat(messagesToProcess);
     const initialItems = allItems.slice(0, MAX_ITEMS_ON_CREATE);
     const remainingItems = allItems.slice(MAX_ITEMS_ON_CREATE);
-    const totalBatches = Math.ceil(remainingItems.length / MAX_ITEMS_PER_BATCH);
     
-    // Concise batch summary
-    logger.info(`[OpenAIResponsesProvider] Batching: ${initialItems.length} (create) + ${remainingItems.length} (${totalBatches} batches) = ${totalItems} total`);
-
-    const payload = this._cleanObject({
-      metadata,
-      items: initialItems,
-      tool_resources: toolResources,
-    });
-
-    let conversation;
-    try {
-      conversation = await this._retryWithRateLimit(async () => {
-        if (this.conversations && typeof this.conversations.create === 'function') {
-          return await this.conversations.create(payload);
-        }
-        return await this._post('/conversations', payload);
-      });
-    } catch (error) {
-      logger.error('[OpenAIResponsesProvider] Failed to create conversation:', error?.message || error);
-      throw error;
+    if (remainingItems.length > 0) {
+      logger.info(`[OpenAIResponsesProvider] Batching ${allItems.length} messages: ${initialItems.length} + ${remainingItems.length}`);
     }
 
-    // Add remaining messages in batches (maintains chronological order)
+    const conversation = await this._createConversationWithItems(metadata, initialItems, toolResources);
+
     if (remainingItems.length > 0) {
       try {
         await this._addItemsInBatches(conversation.id, remainingItems);
@@ -142,95 +87,78 @@ class OpenAIResponsesProvider {
     return conversation;
   }
 
-  /**
-   * Add items to a conversation in batches
-   * Items are converted to API format with type: 'message' for the items.create endpoint
-   * @private
-   */
-  async _addItemsInBatches(threadId, items, batchSize = MAX_ITEMS_PER_BATCH) {
-    if (!items || items.length === 0) {
-      return;
+  async _createConversationWithItems(metadata, items, toolResources) {
+    const payload = {
+      metadata,
+      items: items.length > 0 ? items : undefined,
+      tool_resources: toolResources,
+    };
+
+    try {
+      const { result } = await retryWithBackoff(async () => {
+        return await this.conversations.create(payload);
+      }, { providerName: PROVIDER_NAME });
+      return result;
+    } catch (error) {
+      logger.error('[OpenAIResponsesProvider] Failed to create conversation:', error?.message || error);
+      throw error;
     }
+  }
+
+  async _addItemsInBatches(threadId, items, batchSize = MAX_ITEMS_PER_BATCH) {
+    if (!items?.length) return;
 
     const id = this._ensurethreadId(threadId);
     const totalBatches = Math.ceil(items.length / batchSize);
     
     for (let i = 0; i < items.length; i += batchSize) {
       const batch = items.slice(i, i + batchSize);
-      const batchNumber = Math.floor(i / batchSize) + 1;
-      
       const batchPayload = this._convertItemsToApiFormat(batch);
 
-      try {
-        await this._retryWithRateLimit(async () => {
-          if (this.conversations?.items?.create) {
-            return await this.conversations.items.create(id, { items: batchPayload });
-          }
-          return await this._post(`/conversations/${id}/items`, { items: batchPayload });
-        });
-      } catch (error) {
-        logger.error(`[OpenAIResponsesProvider] Batch ${batchNumber}/${totalBatches} failed:`, error?.message || error);
-        throw error;
-      }
+      await retryWithBackoff(() => 
+        this.conversations.items.create(id, { items: batchPayload })
+      , { providerName: PROVIDER_NAME });
     }
     
     logger.info(`[OpenAIResponsesProvider] Successfully added ${items.length} messages in ${totalBatches} batches`);
   }
 
-  /**
-   * Convert conversation items to API format for items.create endpoint
-   * Adds type: 'message' which is required by the items.create API
-   * @private
-   */
   _convertItemsToApiFormat(items) {
     return items.map(item => ({
-      role: item.role,
-      content: item.content,
-      type: 'message',
+      role: item.role || 'user',
+      content: this._normalizeContent(item.content),
+      type: item.type || 'message',
     }));
   }
 
-  async deleteConversation(threadId) {
-    const id = this._ensurethreadId(threadId);
-    if (this.conversations && typeof this.conversations.del === 'function') {
-      return await this.conversations.delete(id);
+  _normalizeContent(content) {
+    if (typeof content === 'string') return content;
+    if (Array.isArray(content)) return content;
+    if (content && typeof content === 'object') {
+      if (content.text) return content.text;
+      if (content.type === 'text' && content.text) return content.text;
+      return JSON.stringify(content);
     }
-    return await this._delete(`/conversations/${id}`);
+    return content || '';
   }
 
+  /**
+   * Add message to thread/conversation
+   */
   async addMessage({ threadId, messages, role = 'user', content, metadata }) {
     const id = this._ensurethreadId(threadId);
     const messagesToAdd = messages || [{ role, content, metadata }];
     
-    const payloads = messagesToAdd.map(msg => 
-      this._cleanObject({
-        role: msg.role || 'user',
-        content: this._normalizeContent(msg.role || 'user', msg.content),
-        type: 'message',
-      })
-    ).filter(p => p.content);
-
+    const payloads = this._convertItemsToApiFormat(messagesToAdd).filter(p => p.content);
     if (payloads.length === 0) return null;
 
-    if (payloads.length > MAX_ITEMS_PER_BATCH) {
-      logger.info(`[OpenAIResponsesProvider] Batching ${payloads.length} messages into chunks of ${MAX_ITEMS_PER_BATCH}`);
-      await this._addItemsInBatches(id, payloads, MAX_ITEMS_PER_BATCH);
-      return { batched: true, count: payloads.length };
-    }
-
-    return this._retryWithRateLimit(async () => {
-      if (this.conversations?.items?.create) {
-        return await this.conversations.items.create(id, { items: payloads });
-      }
-      return await this._post(`/conversations/${id}/items`, { items: payloads });
-    });
+    await this._addItemsInBatches(id, payloads);
+    return { success: true, count: payloads.length };
   }
 
   async listMessages({ threadId, order = 'desc', limit } = {}) {
     const id = this._ensurethreadId(threadId);
-    const query = this._cleanObject({ order, limit });
-
-    return await this.client.conversations.items.list(id, query);
+    return await this.client.conversations.items.list(id, { order, limit });
   }
 
   async cleanupOrphanedFunctionCalls(threadId, deleteAll = false) {
@@ -243,36 +171,90 @@ class OpenAIResponsesProvider {
 
       if (deleteAll) {
         logger.info(`[OpenAIResponsesProvider] Deleting all ${items.length} items from conversation`);
-        for (const item of items) {
-          await this.conversations.items.delete(item.id, {conversation_id: id});
-        }
+        await Promise.all(items.map(item => 
+          this.conversations.items.delete(item.id, {conversation_id: id})
+        ));
         return;
       }
 
-      const functionCalls = items.filter(item => item.type === 'function_call');
-      const functionOutputs = items.filter(item => item.type === 'function_call_output');
+      const outputCallIds = new Set(items.filter(i => i.type === 'function_call_output').map(o => o.call_id));
+      const orphanedCalls = items.filter(i => i.type === 'function_call' && !outputCallIds.has(i.call_id));
       
-      for (const functionCall of functionCalls) {
-        const hasOutput = functionOutputs.some(output => output.call_id === functionCall.call_id);
-        
-        if (!hasOutput) {
-          logger.info(`[OpenAIResponsesProvider] Deleting orphaned function_call: ${functionCall.id} (${functionCall.call_id})`);
-          await this.conversations.items.delete(functionCall.id, {conversation_id: id});
-        }
+      if (orphanedCalls.length > 0) {
+        await Promise.all(orphanedCalls.map(call => this.conversations.items.delete(call.id, {conversation_id: id})));
       }
     } catch (error) {
       logger.warn('[OpenAIResponsesProvider] Failed to cleanup conversation:', error?.message);
     }
   }
 
+  _normalizeThread(thread) {
+    return {
+      conversationId: thread.conversation_id || thread.getConversationId?.(),
+      assistantId: thread.prompt_id || thread.getAssistantId?.()
+    };
+  }
+
+  /**
+   * Main entry point for running assistant
+   */
+  async executeRun({ thread, assistant, tools = [], config = {} }) {
+    const { conversationId, assistantId } = this._normalizeThread(thread);
+    const preparedConfig = {
+      ...config,
+      assistant,
+      toolMetadata: {
+        numero: thread.code,
+        assistant_id: assistantId
+      }
+    };
+
+    logger.info('[OpenAIResponsesProvider] Starting run', {
+      conversationId,
+      assistantId
+    });
+
+    const filter = thread.code ? { code: thread.code, active: true } : null;
+    const result = await this.runConversation({
+      threadId: conversationId,
+      assistantId,
+      tools,
+      ...preparedConfig
+    });
+
+    const completed = result.status === 'completed';
+    const output = await this.getRunText({ 
+      runId: result.id, 
+      fallback: '' 
+    });
+
+    if (filter) {
+      await Thread.updateOne(filter, { $set: { run_id: null } });
+    }
+
+    logger.info('[OpenAIResponsesProvider] Run complete', {
+      runId: result.id,
+      completed,
+      toolsExecuted: result.tools_executed?.length || 0
+    });
+
+    return {
+      run: result,
+      completed,
+      output,
+      tools_executed: result.tools_executed || [],
+      retries: result.retries || 0
+    };
+  }
+
   async runConversation({
-    assistantId,
     threadId,
-    instructions,
+    assistantId,
     additionalMessages = [],
+    instructions = null,
+    additionalInstructions = null,
     toolOutputs = [],
-    additionalInstructions,
-    metadata,
+    metadata = {},
     topP,
     temperature,
     maxOutputTokens,
@@ -284,56 +266,57 @@ class OpenAIResponsesProvider {
   } = {}) {
     try {
       const id = this._ensurethreadId(threadId);
-      const messages = this._responseInput(additionalMessages) || [];
-
-      const execMetadata = toolMetadata || { thread_id: id, assistant_id: assistantId };
-      let toolsExecuted = [];
+      let input = this._convertItemsToApiFormat(additionalMessages);
+      let allToolsExecuted = [];
+      let totalRetries = 0;
       
+      // Handle pending function calls
       if (assistant && toolOutputs.length === 0) {
-        try {
-          const conversationMessages = await this.listMessages({ threadId: id, order: 'desc', limit: 50 });
-          const items = conversationMessages?.data || [];
-          const result = await handlePendingFunctionCallsUtil(assistant, items, execMetadata);
-          if (result.outputs && result.outputs.length > 0) {
-            toolOutputs = result.outputs;
-            toolsExecuted = result.toolsExecuted || [];
-          }
-        } catch (error) {
-          logger.warn('[OpenAIResponsesProvider] Error checking for pending function calls:', error?.message);
-        }
+        const conversationMessages = await this.listMessages({ threadId: id, order: 'desc', limit: 50 });
+        const result = await handlePendingFunctionCallsUtil(assistant, conversationMessages?.data || [], toolMetadata || { thread_id: id, assistant_id: assistantId });
+        toolOutputs = result.outputs || [];
+        allToolsExecuted = result.toolsExecuted || [];
       }
 
-      // 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 },
-        model: model || this.defaults.responseModel,
-        instructions: additionalInstructions || instructions,
-        input: [...messages, ...toolOutputs],
-        metadata,
-        top_p: topP,
-        temperature,
-        max_output_tokens: maxOutputTokens,
-        truncation_strategy: truncationStrategy,
-        tools: transformedTools,
-      });
-
-      const response = await this._retryWithRateLimit(() => 
-        this.client.responses.create(payload)
-      );
-
-      if (response?.status !== 'completed') {
-        await this.cleanupOrphanedFunctionCalls(id, true);
+      input = [...input, ...toolOutputs];
+      const makeAPICall = (inputData) => retryWithBackoff(() => 
+        this.client.responses.create({
+          conversation: id,
+          prompt: { id: assistantId },
+          model: model || this.defaults.responseModel,
+          instructions: additionalInstructions || instructions,
+          input: inputData,
+          metadata, top_p: topP, temperature, max_output_tokens: maxOutputTokens,
+          truncation_strategy: truncationStrategy,
+          tools: transformToolsForResponsesAPIUtil(this.variant, tools),
+        }), { providerName: PROVIDER_NAME });
+
+      const { result: response, retries } = await makeAPICall(input);
+      totalRetries += retries;
+      let finalResponse = response;
+
+      if (assistant && response.output) {
+        const functionCalls = response.output.filter(item => item.type === 'function_call');
+        
+        if (functionCalls.length > 0) {
+          const { outputs, toolsExecuted } = await handleFunctionCallsUtil(functionCalls, assistant, toolMetadata || { thread_id: id, assistant_id: assistantId });
+          
+          input.push(...outputs);
+          allToolsExecuted.push(...toolsExecuted);
+
+          const { result: followUp, retries: followUpRetries } = await makeAPICall(input);
+          totalRetries += followUpRetries;
+          finalResponse = followUp;
+        }
       }
 
       return {
-        ...response,
+        ...finalResponse,
         thread_id: id,
         assistant_id: assistantId,
-        object: response.object || 'response',
-        tools_executed: toolsExecuted,
+        object: finalResponse.object || 'response',
+        tools_executed: allToolsExecuted,
+        retries: totalRetries,
       };
     } catch (error) {
       logger.error('[OpenAIResponsesProvider] Error running conversation:', error);
@@ -346,73 +329,19 @@ class OpenAIResponsesProvider {
     return await this.client.responses.retrieve(id);
   }
 
-  async listRuns({ threadId, limit, order = 'desc', activeOnly = false } = {}) {
-    return { data: [] };
-  }
-
-  async submitToolOutputs({ threadId, runId, toolOutputs }) {
-    const responseId = this._ensureResponseId(runId);
-    return await this._post(`/responses/${responseId}/submit_tool_outputs`, {
-      tool_outputs: toolOutputs,
-    });
-  }
-
-  async cancelRun({ threadId, runId }) {
-    const responseId = this._ensureResponseId(runId);
-    return this._post(`/responses/${responseId}/cancel`);
-  }
-
-  async getRunText({
-    threadId,
-    runId,
-    messageIndex = 0,
-    contentIndex = 0,
-    fallback = '',
-  } = {}) {
+  async getRunText({ runId, messageIndex = 0, contentIndex = 0, fallback = '' } = {}) {
     const response = await this.client.responses.retrieve(this._ensureResponseId(runId));
     if (!response) return fallback;
-
-    if (response.output_text) {
-      return response.output_text;
-    }
-
-    const output = Array.isArray(response.output) ? response.output : [];
-    const item = output[messageIndex];
-    if (!item || !Array.isArray(item.content)) {
-      return fallback;
-    }
-    const content = item.content[contentIndex];
-    if (content?.type === 'output_text' && typeof content.text === 'string') {
-      return content.text;
-    }
-
-    return fallback;
+    
+    if (response.output_text) return response.output_text;
+    
+    const text = response.output?.[messageIndex]?.content?.[contentIndex]?.text;
+    return text || fallback;
   }
 
   /**
    * Generic helpers
    */
-
-  async createChatCompletion({ model, messages, temperature, maxTokens, topP, metadata, responseFormat } = {}) {
-    return this.client.chat.completions.create({
-      model: model || this.defaults.chatModel,
-      messages,
-      temperature,
-      max_tokens: maxTokens,
-      top_p: topP,
-      metadata,
-      response_format: responseFormat,
-    });
-  }
-
-  async uploadFile({ file, purpose }) {
-    if (!file) {
-      throw new Error('uploadFile requires a readable file stream or object');
-    }
-
-    return this.client.files.create({ file, purpose: purpose || 'assistants' });
-  }
-
   async transcribeAudio({ file, model, language, responseFormat, temperature, prompt } = {}) {
     return this.client.audio.transcriptions.create({
       model: model || this.defaults.transcriptionModel,
@@ -424,78 +353,6 @@ class OpenAIResponsesProvider {
     });
   }
 
-  async handleRequiresAction(assistant, run, threadId) {
-    return await handleRequiresActionUtil(assistant, run);
-  }
-
-  async checkRunStatus(assistant, thread_id, run_id, retryCount = 0, maxRetries = DEFAULT_MAX_RETRIES, actionHandled = false, toolMetadata = {}, accumulatedTools = []) {
-    try {
-      let run = await this.getRun({ threadId: thread_id, runId: run_id });
-      logger.info(`Status: ${run.status} ${thread_id} ${run_id} (attempt ${retryCount + 1})`);
-
-      if (run.status === 'completed') {
-        return {run, completed: true, tools_executed: accumulatedTools};
-      }
-
-      if (run.status === 'failed' || run.status === 'cancelled' || run.status === 'expired') {
-        return {run, completed: false, tools_executed: accumulatedTools};
-      }
-
-      const needsFunctionCall = run.output?.some(item => item.type === 'function_call');
-      if (needsFunctionCall && !actionHandled) {
-        if (retryCount >= maxRetries) {
-          logger.warn('[OpenAIResponsesProvider] Max retries reached while handling function calls');
-          return {run, completed: false, tools_executed: accumulatedTools};
-        }
-
-        const execMetadata = { ...toolMetadata, thread_id, run_id };
-        const result = await handleRequiresActionUtil(assistant, run, execMetadata);
-        const outputs = result.outputs || [];
-        const toolsExecuted = result.toolsExecuted || [];
-        
-        logger.info('[OpenAIResponsesProvider] Function call outputs:', outputs);
-        
-        if (outputs.length > 0) {
-          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, toolMetadata, [...accumulatedTools, ...toolsExecuted]);
-          } catch (submitError) {
-            logger.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, toolMetadata, accumulatedTools);
-            }
-            return {run, completed: false, tools_executed: accumulatedTools};
-          }
-        } else {
-          logger.warn('[OpenAIResponsesProvider] Function calls detected but no outputs generated');
-          return {run, completed: false, tools_executed: accumulatedTools};
-        }
-      }
-
-      if (retryCount < maxRetries) {
-        await new Promise(resolve => setTimeout(resolve, 1000));
-        return this.checkRunStatus(assistant, thread_id, run_id, retryCount + 1, maxRetries, actionHandled, toolMetadata, accumulatedTools);
-      }
-
-      return {run, completed: false, tools_executed: accumulatedTools};
-    } catch (error) {
-      logger.error('[OpenAIResponsesProvider] Error checking run status:', error);
-      return {run: null, completed: false, tools_executed: accumulatedTools};
-    }
-  }
-
-
-  /**
-   * Internal helpers
-   */
   _ensurethreadId(value) {
     const id = this._ensureId(value);
     if (!id.startsWith(CONVERSATION_PREFIX)) {
@@ -525,104 +382,17 @@ class OpenAIResponsesProvider {
     throw new Error('Unable to resolve identifier value');
   }
 
-  _cleanObject(payload) {
-    if (payload === undefined || payload === null) {
-      return undefined;
-    }
-
-    if (Array.isArray(payload)) {
-      return payload
-        .map((entry) => this._cleanObject(entry))
-        .filter((entry) => !(entry === undefined || entry === null || (typeof entry === 'object' && !Array.isArray(entry) && Object.keys(entry).length === 0)));
-    }
-
-    if (typeof payload !== 'object') {
-      return payload;
-    }
-
-    const cleaned = { ...payload };
-    Object.keys(cleaned).forEach((key) => {
-      const value = cleaned[key];
-      if (value === undefined || value === null) {
-        delete cleaned[key];
-        return;
-      }
-
-      if (typeof value === 'object') {
-        const nested = this._cleanObject(value);
-        if (nested === undefined || nested === null || (typeof nested === 'object' && !Array.isArray(nested) && Object.keys(nested).length === 0)) {
-          delete cleaned[key];
-        } else {
-          cleaned[key] = nested;
-        }
-      }
-    });
-    return cleaned;
-  }
-
-  _normalizeContent(role, content) {
-    const normalized = this._normalizeContentParts(content);
-    return normalized.map((part) => {
-      if (part.type === 'text') {
-        return { type: role === 'assistant' ? 'output_text' : 'input_text', text: part.text };
-      } else if (part.type === 'image_file') {
-        return { type: 'input_image', file_id: part?.image_file?.file_id };
-      }
-      return part;
-    });
-  }
-
-  _normalizeContentParts(content) {
-    if (content === undefined || content === null) {
-      return [{ type: 'text', text: '' }];
-    }
-
-    if (Array.isArray(content)) {
-      return content.map((item) => {
-        if (typeof item === 'string') {
-          return { type: 'text', text: item };
-        }
-        return item;
-      });
-    }
-
-    if (typeof content === 'string') {
-      return [{ type: 'text', text: content }];
-    }
-
-    return [content];
-  }
-
-  _conversationItems(messages = []) {
-    if (!Array.isArray(messages)) return [];
-    return messages
-      .map((message) => {
-        if (!message) return null;
-        const role = message.role || 'user';
-        return {
-          role,
-          content: this._normalizeContent(role, message.content),
-        };
-      })
-      .filter(Boolean);
-  }
-
-  _responseInput(messages = []) {
-    const items = this._conversationItems(messages);
-    return items.length ? items : undefined;
-  }
-
   async _post(path, body, options = {}) {
     return this.client.post(path, {
       ...options,
-      body: this._cleanObject(body),
+      body,
     });
   }
 
   async _get(path, query, options = {}) {
     return this.client.get(path, {
       ...options,
-      query: this._cleanObject(query),
+      query,
     });
   }