@peopl-health/nexus 1.7.12 → 2.0.1

package/lib/providers/{OpenAIProvider.js → OpenAIAssistantsProvider.js}

@@ -1,11 +1,11 @@
 const { OpenAI } = require('openai');
 
 /**
- * Wrapper around the OpenAI SDK that exposes a higher level interface for
- * common operations while remaining compatible with existing callers that
- * expect the raw SDK surface (e.g. `.beta`).
+ * Provider wrapper that targets the legacy Assistants (threads/runs) API surface.
+ * Consumers can continue using the existing helper methods while we gradually
+ * migrate to the new Responses API.
  */
-class OpenAIProvider {
+class OpenAIAssistantsProvider {
   constructor(options = {}) {
     const {
       apiKey = process.env.OPENAI_API_KEY,
@@ -15,7 +15,7 @@ class OpenAIProvider {
     } = options;
 
     if (!client && !apiKey) {
-      throw new Error('OpenAIProvider requires an API key or a preconfigured client');
+      throw new Error('OpenAIAssistantsProvider requires an API key or a preconfigured client');
     }
 
     this.client = client || new OpenAI({ apiKey, organization });
@@ -27,12 +27,11 @@ class OpenAIProvider {
       ...defaultModels,
     };
 
-    // Expose raw SDK sub-clients for backward compatibility
-    this.beta = this.client.beta;
-    this.responses = this.client.responses;
-    this.chat = this.client.chat;
-    this.audio = this.client.audio;
-    this.files = this.client.files;
+    this.variant = 'assistants';
+  }
+
+  getVariant() {
+    return this.variant;
   }
 
   getClient() {
@@ -47,24 +46,23 @@ class OpenAIProvider {
 
     if (Array.isArray(messages) && messages.length > 0) {
       for (const message of messages) {
-        await this.addMessage({ conversationId: thread.id, ...message });
+        await this.addMessage({ threadId: thread.id, ...message });
       }
     }
 
     return thread;
   }
 
-  async deleteConversation(conversationId) {
-    await this.client.beta.threads.del(this._ensureId(conversationId));
+  async deleteConversation(threadId) {
+    await this.client.beta.threads.del(this._ensureId(threadId));
   }
 
-  async addMessage({ conversationId, role = 'user', content, attachments = [], metadata }) {
+  async addMessage({ threadId, role = 'user', content, metadata }) {
     const formattedContent = this._normalizeContent(content);
 
     const payload = {
       role,
       content: formattedContent,
-      attachments,
       metadata,
     };
 
@@ -72,15 +70,11 @@ class OpenAIProvider {
       delete payload.metadata;
     }
 
-    if (!payload.attachments || payload.attachments.length === 0) {
-      delete payload.attachments;
-    }
-
-    return this.client.beta.threads.messages.create(this._ensureId(conversationId), payload);
+    return this.client.beta.threads.messages.create(this._ensureId(threadId), payload);
   }
 
-  async listMessages({ conversationId, runId, order = 'desc', limit } = {}) {
-    return this.client.beta.threads.messages.list(this._ensureId(conversationId), {
+  async listMessages({ threadId, runId, order = 'desc', limit } = {}) {
+    return this.client.beta.threads.messages.list(this._ensureId(threadId), {
       run_id: runId,
       order,
       limit,
@@ -88,13 +82,13 @@ class OpenAIProvider {
   }
 
   async getRunText({
-    conversationId,
+    threadId,
     runId,
     messageIndex = 0,
     contentIndex = 0,
     fallback = '',
   } = {}) {
-    const messages = await this.listMessages({ conversationId, runId });
+    const messages = await this.listMessages({ threadId, runId });
     const message = messages?.data?.[messageIndex];
     const content = message?.content?.[contentIndex];
 
@@ -114,7 +108,7 @@ class OpenAIProvider {
   }
 
   async runConversation({
-    conversationId,
+    threadId,
     assistantId,
     instructions,
     additionalMessages = [],
@@ -157,85 +151,48 @@ class OpenAIProvider {
       }
     });
 
-    return this.client.beta.threads.runs.create(this._ensureId(conversationId), payload);
+    return this.client.beta.threads.runs.create(this._ensureId(threadId), payload);
   }
 
-  async getRun({ conversationId, runId }) {
-    return this.client.beta.threads.runs.retrieve(this._ensureId(conversationId), this._ensureId(runId));
+  async getRun({ threadId, runId }) {
+    const run = await this.client.beta.threads.runs.retrieve(this._ensureId(runId), { thread_id: this._ensureId(threadId) });
+    return run;
   }
 
-  async listRuns({ conversationId, limit, order = 'desc', activeOnly = false } = {}) {
-    const runs = await this.client.beta.threads.runs.list(this._ensureId(conversationId), {
+  async listRuns({ threadId, limit, order = 'desc', activeOnly = false } = {}) {
+    const runs = await this.client.beta.threads.runs.list(this._ensureId(threadId), {
       limit,
       order,
     });
-    
+
     if (activeOnly) {
       const activeStatuses = ['in_progress', 'queued', 'requires_action'];
       return {
         ...runs,
-        data: runs.data.filter(run => activeStatuses.includes(run.status))
+        data: runs.data.filter((run) => activeStatuses.includes(run.status)),
       };
     }
-    
+
     return runs;
   }
 
-  async submitToolOutputs({ conversationId, runId, toolOutputs }) {
+  async submitToolOutputs({ threadId, runId, toolOutputs }) {
     return this.client.beta.threads.runs.submitToolOutputs(
-      this._ensureId(conversationId),
       this._ensureId(runId),
-      { tool_outputs: toolOutputs }
+      { 
+        thread_id: this._ensureId(threadId) ,
+        tool_outputs: toolOutputs
+      }
     );
   }
 
-  async cancelRun({ conversationId, runId }) {
+  async cancelRun({ threadId, runId }) {
     return this.client.beta.threads.runs.cancel(
-      this._ensureId(conversationId),
-      this._ensureId(runId)
+      this._ensureId(runId),
+      { thread_id: this._ensureId(threadId) }
     );
   }
 
-  async runPrompt({
-    model,
-    input,
-    instructions,
-    reasoningEffort = this.defaults.reasoningEffort,
-    responseFormat,
-    metadata,
-    temperature,
-    maxOutputTokens,
-    tools,
-  } = {}) {
-    const payload = {
-      model: model || this.defaults.responseModel,
-      input,
-      instructions,
-      reasoning: reasoningEffort ? { effort: reasoningEffort } : undefined,
-      text: responseFormat ? { format: responseFormat } : undefined,
-      metadata,
-      temperature,
-      max_output_tokens: maxOutputTokens,
-      tools,
-    };
-
-    if (Array.isArray(payload.tools) && payload.tools.length === 0) {
-      delete payload.tools;
-    }
-
-    if (payload.metadata && Object.keys(payload.metadata).length === 0) {
-      delete payload.metadata;
-    }
-
-    Object.keys(payload).forEach((key) => {
-      if (payload[key] === undefined || payload[key] === null) {
-        delete payload[key];
-      }
-    });
-
-    return this.client.responses.create(payload);
-  }
-
   async createChatCompletion({ model, messages, temperature, maxTokens, topP, metadata, responseFormat } = {}) {
     return this.client.chat.completions.create({
       model: model || this.defaults.chatModel,
@@ -303,5 +260,5 @@ class OpenAIProvider {
 }
 
 module.exports = {
-  OpenAIProvider,
+  OpenAIAssistantsProvider,
 };

package/lib/providers/OpenAIResponsesProvider.js

@@ -0,0 +1,380 @@
+const { OpenAI } = require('openai');
+
+const CONVERSATION_PREFIX = 'conv_';
+const RESPONSE_PREFIX = 'resp_';
+
+/**
+ * Provider wrapper that targets the Conversations + Responses API surface.
+ */
+class OpenAIResponsesProvider {
+  constructor(options = {}) {
+    const {
+      apiKey = process.env.OPENAI_API_KEY,
+      organization,
+      client,
+      defaultModels = {},
+    } = options;
+
+    if (!client && !apiKey) {
+      throw new Error('OpenAIResponsesProvider requires an API key or a preconfigured client');
+    }
+
+    this.client = client || new OpenAI({ apiKey, organization });
+    this.defaults = {
+      responseModel: 'o4-mini',
+      chatModel: 'gpt-4o-mini',
+      transcriptionModel: 'whisper-1',
+      reasoningEffort: 'medium',
+      ...defaultModels,
+    };
+
+    this.variant = 'responses';
+
+    this.responses = this.client.responses;
+    this.conversations = this.client.conversations;
+  }
+
+  getVariant() {
+    return this.variant;
+  }
+
+  getClient() {
+    return this.client;
+  }
+
+  /**
+   * Conversations helpers
+   */
+  async createConversation({ metadata, messages = [], toolResources } = {}) {
+    const payload = this._cleanObject({
+      metadata,
+      items: this._conversationItems(messages),
+      tool_resources: toolResources,
+    });
+
+    if (this.conversations && typeof this.conversations.create === 'function') {
+      return await this.conversations.create(payload);
+    }
+
+    return await this._post('/conversations', payload);
+  }
+
+  async deleteConversation(threadId) {
+    const id = this._ensurethreadId(threadId);
+    if (this.conversations && typeof this.conversations.del === 'function') {
+      return await this.conversations.del(id);
+    }
+    return await this._delete(`/conversations/${id}`);
+  }
+
+  async addMessage({ threadId, role = 'user', content, metadata }) {
+    const id = this._ensurethreadId(threadId);
+    const payload = this._cleanObject({
+      role,
+      content: this._normalizeContent(role, content),
+      type: 'message',
+    });
+    console.log('payload', payload);
+
+    if (payload.content) {
+      if (this.conversations?.items?.create) {
+        return await this.conversations.items.create(id, {items: [payload]});
+      }
+      return await this._post(`/conversations/${id}/items`, {items: [payload]});
+    }
+  }
+
+  async listMessages({ threadId, order = 'desc', limit } = {}) {
+    const id = this._ensurethreadId(threadId);
+    const query = this._cleanObject({ order, limit });
+
+    if (this.conversations?.items && typeof this.conversations.items.list === 'function') {
+      return await this.conversations.items.list(id, query);
+    }
+
+    return await this._get(`/conversations/${id}/items`, query);
+  }
+
+  async runConversation({
+    assistantId,
+    threadId,
+    conversationId,
+    promptId,
+    instructions,
+    additionalMessages = [],
+    additionalInstructions,
+    metadata,
+    topP,
+    temperature,
+    maxOutputTokens,
+    truncationStrategy,
+    tools = [],
+  } = {}) {
+    const id = this._ensurethreadId(conversationId || threadId);
+
+    const payload = this._cleanObject({
+      conversation: id,
+      prompt: { id: promptId },
+      instructions: additionalInstructions || instructions,
+      input: this._responseInput(additionalMessages),
+      metadata,
+      top_p: topP,
+      temperature,
+      max_output_tokens: maxOutputTokens,
+      truncation_strategy: truncationStrategy,
+      tools: Array.isArray(tools) && tools.length ? tools : undefined,
+    });
+
+    const response = await this.client.responses.create(payload);
+    return {
+      ...response,
+      thread_id: id,
+      assistant_id: assistantId,
+      object: response.object || 'response',
+    };
+  }
+
+  async getRun({ threadId, runId }) {
+    const id = this._ensureResponseId(runId);
+    return await this.client.responses.retrieve(id);
+  }
+
+  async listRuns({ threadId, limit, order = 'desc', activeOnly = false } = {}) {
+    const id = this._ensurethreadId(threadId);
+    const query = this._cleanObject({ conversation: id, limit, order });
+
+    let responseList;
+    try {
+      responseList = await this._get('/responses', query);
+    } catch (error) {
+      console.warn('[OpenAIResponsesProvider] Failed to list responses:', error?.message || error);
+      responseList = { data: [] };
+    }
+
+    if (!activeOnly) {
+      return responseList;
+    }
+
+    const activeStatuses = ['queued', 'in_progress', 'processing', 'requires_action'];
+    const data = Array.isArray(responseList?.data)
+      ? responseList.data.filter((run) => activeStatuses.includes(run.status))
+      : [];
+
+    return { ...responseList, 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 = '',
+  } = {}) {
+    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;
+  }
+
+  /**
+   * 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,
+      file,
+      language,
+      response_format: responseFormat,
+      temperature,
+      prompt,
+    });
+  }
+
+  /**
+   * Internal helpers
+   */
+  _ensurethreadId(value) {
+    const id = this._ensureId(value);
+    if (!id.startsWith(CONVERSATION_PREFIX)) {
+      throw new Error(`Expected conversation id to start with '${CONVERSATION_PREFIX}'`);
+    }
+    return id;
+  }
+
+  _ensureResponseId(value) {
+    const id = this._ensureId(value);
+    if (!id.startsWith(RESPONSE_PREFIX)) {
+      throw new Error(`Expected response id to start with '${RESPONSE_PREFIX}'`);
+    }
+    return id;
+  }
+
+  _ensureId(value) {
+    if (!value) {
+      throw new Error('Identifier value is required');
+    }
+    if (typeof value === 'string') {
+      return value;
+    }
+    if (typeof value === 'object' && value.id) {
+      return value.id;
+    }
+    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),
+    });
+  }
+
+  async _get(path, query, options = {}) {
+    return this.client.get(path, {
+      ...options,
+      query: this._cleanObject(query),
+    });
+  }
+
+  async _delete(path, options = {}) {
+    return this.client.delete(path, options);
+  }
+}
+
+module.exports = {
+  OpenAIResponsesProvider,
+};

package/lib/providers/createProvider.js

@@ -0,0 +1,24 @@
+const { OpenAIAssistantsProvider } = require('./OpenAIAssistantsProvider');
+const { OpenAIResponsesProvider } = require('./OpenAIResponsesProvider');
+
+const PROVIDER_VARIANTS = {
+  assistants: OpenAIAssistantsProvider,
+  responses: OpenAIResponsesProvider,
+};
+
+/**
+ * Returns the appropriate OpenAI provider implementation for the requested variant.
+ */
+function createProvider(config = {}) {
+  const variant = (config.variant || config.providerVariant || config.llmVariant || 'assistants')
+    .toString()
+    .toLowerCase();
+
+  const ProviderClass = PROVIDER_VARIANTS[variant] || OpenAIAssistantsProvider;
+  return new ProviderClass({ ...config, variant });
+}
+
+module.exports = {
+  createProvider,
+  PROVIDER_VARIANTS,
+};