@peopl-health/nexus 1.5.8 → 1.5.9

package/examples/assistants/BaseAssistant.js

@@ -1,242 +1 @@
-/**
- * Base Assistant class for consumer server extensions
- * Provides common functionality for AI assistant implementations
- */
-class BaseAssistant {
-  constructor(config = {}) {
-    this.assistantId = config.assistantId;
-    this.llmClient = config.llmClient;
-    this.storage = config.storage;
-    this.nexus = config.nexus;
-    this.functions = new Map();
-  }
-
-  /**
-   * Register a function that can be called by the assistant
-   * @param {string} name - Function name
-   * @param {Function} handler - Function handler
-   * @param {Object} schema - Function schema for LLM
-   */
-  registerFunction(name, handler, schema) {
-    this.functions.set(name, { handler, schema });
-  }
-
-  /**
-   * Get all registered function schemas for LLM
-   * @returns {Array} Function schemas
-   */
-  getFunctionSchemas() {
-    return Array.from(this.functions.values()).map(f => f.schema);
-  }
-
-  /**
-   * Execute a function call from the assistant
-   * @param {string} name - Function name
-   * @param {Object} args - Function arguments
-   * @returns {Promise<any>} Function result
-   */
-  async executeFunction(name, args) {
-    const func = this.functions.get(name);
-    if (!func) {
-      throw new Error(`Unknown function: ${name}`);
-    }
-    return await func.handler(args);
-  }
-
-  /**
-   * Create a new thread for this assistant
-   * @param {string} userId - User identifier
-   * @param {Array} initialMessages - Initial messages
-   * @returns {Promise<Object>} Thread data
-   */
-  async createThread(userId, initialMessages = []) {
-    if (!this.llmClient) {
-      throw new Error('LLM client not configured');
-    }
-
-    const thread = await this.llmClient.beta.threads.create();
-    
-    // Add initial messages if provided
-    for (const message of initialMessages) {
-      await this.llmClient.beta.threads.messages.create(
-        thread.id, 
-        { role: "assistant", content: message }
-      );
-    }
-
-    const threadData = {
-      code: userId,
-      assistantId: this.assistantId,
-      threadId: thread.id,
-      active: true,
-      createdAt: new Date()
-    };
-
-    // Save to storage if available
-    if (this.storage) {
-      await this.storage.createThread(threadData);
-    }
-
-    return threadData;
-  }
-
-  /**
-   * Send message to assistant and handle response
-   * @param {string} userId - User identifier
-   * @param {string} message - User message
-   * @param {Object} options - Additional options
-   * @returns {Promise<string>} Assistant response
-   */
-  async sendMessage(userId, message, options = {}) {
-    if (!this.llmClient) {
-      throw new Error('LLM client not configured');
-    }
-
-    // Get or create thread
-    let threadData = null;
-    if (this.storage) {
-      threadData = await this.storage.getThread(userId);
-    }
-
-    if (!threadData) {
-      threadData = await this.createThread(userId);
-    }
-
-    // Add user message to thread
-    await this.llmClient.beta.threads.messages.create(
-      threadData.threadId,
-      { role: "user", content: message }
-    );
-
-    // Create run with function schemas if available
-    const runConfig = {
-      assistant_id: this.assistantId,
-      ...options
-    };
-
-    const functionSchemas = this.getFunctionSchemas();
-    if (functionSchemas.length > 0) {
-      runConfig.tools = functionSchemas;
-    }
-
-    const run = await this.llmClient.beta.threads.runs.create(
-      threadData.threadId,
-      runConfig
-    );
-
-    // Wait for completion and handle function calls
-    const result = await this.waitForCompletion(threadData.threadId, run.id);
-    
-    if (result.status === 'completed') {
-      const messages = await this.llmClient.beta.threads.messages.list(
-        threadData.threadId, 
-        { run_id: run.id }
-      );
-      return messages.data[0]?.content[0]?.text?.value || "";
-    }
-
-    return null;
-  }
-
-  /**
-   * Wait for run completion and handle function calls
-   * @param {string} threadId - Thread ID
-   * @param {string} runId - Run ID
-   * @returns {Promise<Object>} Run result
-   */
-  async waitForCompletion(threadId, runId) {
-    const maxAttempts = 30;
-    let attempts = 0;
-
-    while (attempts < maxAttempts) {
-      const run = await this.llmClient.beta.threads.runs.retrieve(threadId, runId);
-      
-      if (run.status === 'completed') {
-        return { status: 'completed', run };
-      } else if (run.status === 'requires_action') {
-        // Handle function calls
-        const toolOutputs = await this.handleRequiredActions(run);
-        
-        if (toolOutputs.length > 0) {
-          await this.llmClient.beta.threads.runs.submitToolOutputs(
-            threadId,
-            runId,
-            { tool_outputs: toolOutputs }
-          );
-          
-          // Continue waiting for completion
-          attempts = 0; // Reset attempts after submitting outputs
-          await this.delay(2000);
-          continue;
-        }
-      } else if (run.status === 'failed' || run.status === 'cancelled' || run.status === 'expired') {
-        return { status: 'failed', run };
-      }
-
-      await this.delay(2000);
-      attempts++;
-    }
-
-    throw new Error('Assistant run timeout');
-  }
-
-  /**
-   * Handle required actions (function calls)
-   * @param {Object} run - Run object with required actions
-   * @returns {Promise<Array>} Tool outputs
-   */
-  async handleRequiredActions(run) {
-    const toolCalls = run.required_action?.submit_tool_outputs?.tool_calls || [];
-    const toolOutputs = [];
-
-    for (const toolCall of toolCalls) {
-      try {
-        const functionName = toolCall.function.name;
-        const args = JSON.parse(toolCall.function.arguments);
-        
-        const result = await this.executeFunction(functionName, args);
-        
-        toolOutputs.push({
-          tool_call_id: toolCall.id,
-          output: JSON.stringify(result)
-        });
-      } catch (error) {
-        console.error(`Error executing function ${toolCall.function.name}:`, error);
-        toolOutputs.push({
-          tool_call_id: toolCall.id,
-          output: JSON.stringify({ error: error.message })
-        });
-      }
-    }
-
-    return toolOutputs;
-  }
-
-  /**
-   * Send a message through Nexus
-   * @param {string} to - Recipient
-   * @param {string} message - Message text
-   * @param {Object} options - Additional options
-   */
-  async sendNexusMessage(to, message, options = {}) {
-    if (!this.nexus) {
-      throw new Error('Nexus instance not provided');
-    }
-
-    return await this.nexus.sendMessage({
-      to,
-      message,
-      ...options
-    });
-  }
-
-  /**
-   * Utility delay function
-   * @param {number} ms - Milliseconds to delay
-   */
-  delay(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
-  }
-}
-
-module.exports = { BaseAssistant };
+module.exports = require('../../lib/assistants/BaseAssistant');

package/examples/assistants/DoctorScheduleAssistant.js

@@ -0,0 +1,83 @@
+const { BaseAssistant } = require('../../lib/assistants/BaseAssistant');
+
+class DoctorScheduleAssistant extends BaseAssistant {
+  constructor(thread) {
+    super({ assistantId: 'doctor_schedule', thread });
+
+    this.registerTool({
+      name: 'storePatientAppointment',
+      description: 'Stores a requested appointment so that an operator can follow up with the patient.',
+      parameters: {
+        type: 'object',
+        required: ['contact_number', 'appointment_type'],
+        properties: {
+          contact_number: {
+            type: 'string',
+            description: 'WhatsApp phone number of the patient in international format (e.g. +521234567890).'
+          },
+          appointment_type: {
+            type: 'string',
+            description: 'Type of medical appointment requested by the patient.'
+          },
+          patient_name: {
+            type: 'string',
+            description: 'Full name of the patient if provided.'
+          },
+          preferred_date: {
+            type: 'string',
+            description: 'Preferred appointment date in ISO format (YYYY-MM-DD).'
+          },
+          preferred_time: {
+            type: 'string',
+            description: 'Preferred appointment time in HH:mm format.'
+          },
+          notes: {
+            type: 'string',
+            description: 'Any extra notes supplied by the patient.'
+          }
+        }
+      },
+      handler: async (payload = {}) => {
+        console.log('[DoctorScheduleAssistant] storePatientAppointment', payload);
+
+        if (!payload.contact_number || !payload.appointment_type) {
+          return JSON.stringify({
+            success: false,
+            message: 'Falta el número de contacto o el tipo de cita. Pide esa información al paciente.'
+          });
+        }
+
+        const normalizedNumber = String(payload.contact_number).replace(/[^0-9+]/g, '');
+
+        const appointment = {
+          contact_number: normalizedNumber,
+          appointment_type: payload.appointment_type,
+          patient_name: payload.patient_name || null,
+          preferred_date: payload.preferred_date || null,
+          preferred_time: payload.preferred_time || null,
+          notes: payload.notes || null
+        };
+
+        console.log('[DoctorScheduleAssistant] Appointment captured', appointment);
+
+        return JSON.stringify({ success: true, appointment });
+      }
+    });
+  }
+
+  async create(code, curRow) {
+    await super.create(code, curRow);
+
+    const summary = this.lastMessages
+      ? [{ role: 'assistant', content: `Últimos mensajes:
+${this.lastMessages}` }]
+      : [];
+
+    const client = this.client;
+    if (!client) throw new Error('OpenAI client not configured');
+
+    return await client.beta.threads.create({ messages: summary });
+  }
+}
+
+module.exports = { DoctorScheduleAssistant };

package/examples/assistants/index.js

@@ -1,7 +1,9 @@
 const { BaseAssistant } = require('./BaseAssistant');
 const { ExampleAssistant } = require('./ExampleAssistant');
+const { DoctorScheduleAssistant } = require('./DoctorScheduleAssistant');
 
 module.exports = {
   BaseAssistant,
-  ExampleAssistant
+  ExampleAssistant,
+  DoctorScheduleAssistant
 };

package/lib/assistants/BaseAssistant.js

@@ -0,0 +1,294 @@
+const llmConfig = require('../config/llmConfig');
+const { Thread } = require('../models/threadModel');
+const { getLastNMessages } = require('../helpers/assistantHelper');
+
+/**
+ * Flexible base assistant implementation that integrates with OpenAI Threads
+ * and supports dynamic tool registration.
+ */
+class BaseAssistant {
+  constructor(input = {}) {
+    const options = this._normalizeOptions(input);
+
+    this.assistantId = options.assistantId || null;
+    this.thread = options.thread || null;
+    this.status = options.status || 'idle';
+    this.replies = null;
+    this.lastMessages = null;
+    this.createdAt = new Date();
+
+    this.client = options.client || llmConfig.openaiClient || null;
+    this.tools = new Map();
+
+    if (Array.isArray(options.tools)) {
+      options.tools.forEach((tool) => this.registerTool(tool));
+    }
+
+    if (options.setup && typeof options.setup === 'function') {
+      options.setup.call(this, options);
+    }
+
+    if (this.assistantId) {
+      console.log(`Assistant ${this.assistantId} initialized.`);
+    }
+  }
+
+  _normalizeOptions(input) {
+    if (!input || typeof input !== 'object') {
+      return { thread: input };
+    }
+
+    if (input && input._id && !input.assistantId && !input.client && !input.tools) {
+      return { thread: input };
+    }
+
+    return input;
+  }
+
+  _ensureClient() {
+    if (!this.client) {
+      throw new Error('LLM client not configured. Ensure openaiClient is initialized.');
+    }
+  }
+
+  async getAssistantId() {
+    return this.assistantId;
+  }
+
+  async getStatus() {
+    return this.status;
+  }
+
+  async getNextAssistant() {
+    return this.nextAssistant || null;
+  }
+
+  setThread(thread) {
+    this.thread = thread;
+  }
+
+  setReplies(replies) {
+    this.replies = replies;
+  }
+
+  registerTool(nameOrConfig, schema, handler) {
+    let name;
+    let definition;
+    let executor;
+
+    if (typeof nameOrConfig === 'object' && nameOrConfig !== null) {
+      name = nameOrConfig.name;
+      definition = nameOrConfig.definition || nameOrConfig.schema || nameOrConfig;
+      executor = nameOrConfig.handler || nameOrConfig.execute || nameOrConfig.run;
+    } else {
+      name = nameOrConfig;
+      definition = schema;
+      executor = handler;
+    }
+
+    if (!name || typeof name !== 'string') {
+      throw new Error('Tool name is required');
+    }
+
+    if (!definition || typeof definition !== 'object') {
+      throw new Error(`Tool definition for '${name}' must be an object`);
+    }
+
+    if (!executor || typeof executor !== 'function') {
+      throw new Error(`Tool handler for '${name}' must be a function`);
+    }
+
+    const toolSchema = {
+      type: 'function',
+      function: {
+        name,
+        description: definition.description || 'Custom assistant tool',
+        parameters: definition.parameters || {
+          type: 'object',
+          properties: {},
+          additionalProperties: true
+        }
+      }
+    };
+
+    this.tools.set(name, {
+      schema: toolSchema,
+      execute: executor
+    });
+  }
+
+  getToolSchemas() {
+    return Array.from(this.tools.values()).map((value) => value.schema);
+  }
+
+  async executeTool(name, args) {
+    const tool = this.tools.get(name);
+    if (!tool) {
+      throw new Error(`Unknown tool '${name}' requested by assistant`);
+    }
+    return await tool.execute(args);
+  }
+
+  async createThread(code, context = {}) {
+    return await this.create(code, context);
+  }
+
+  async sendMessage(userId, message, options = {}) {
+    this._ensureClient();
+
+    if (!this.thread || !this.thread.thread_id) {
+      throw new Error('Assistant thread not initialized. Call create() before sendMessage().');
+    }
+
+    await this.client.beta.threads.messages.create(
+      this.thread.thread_id,
+      { role: 'user', content: message }
+    );
+
+    const runConfig = {
+      assistant_id: this.assistantId,
+      ...options
+    };
+
+    const toolSchemas = this.getToolSchemas();
+    if (toolSchemas.length > 0) {
+      runConfig.tools = toolSchemas;
+    }
+
+    const run = await this.client.beta.threads.runs.create(
+      this.thread.thread_id,
+      runConfig
+    );
+
+    return await this.waitForCompletion(this.thread.thread_id, run.id);
+  }
+
+  async waitForCompletion(threadId, runId, { interval = 2000, maxAttempts = 30 } = {}) {
+    this._ensureClient();
+    let attempts = 0;
+
+    while (attempts < maxAttempts) {
+      const run = await this.client.beta.threads.runs.retrieve(threadId, runId);
+
+      if (run.status === 'completed') {
+        return run;
+      }
+
+      if (run.status === 'requires_action') {
+        await this.handleRequiresAction(run);
+      } else if (['failed', 'cancelled', 'expired', 'incomplete'].includes(run.status)) {
+        throw new Error(`Assistant run ended with status '${run.status}'`);
+      }
+
+      await new Promise((resolve) => setTimeout(resolve, interval));
+      attempts += 1;
+    }
+
+    throw new Error('Assistant run timeout');
+  }
+
+  async getPreviousMessages(threadDoc) {
+    this._ensureClient();
+    const threadRef = threadDoc || this.thread;
+    if (!threadRef) return [];
+
+    const response = await this.client.beta.threads.messages.list(threadRef.thread_id, { order: 'asc' });
+    return response.data.map((msg) => {
+      const textContents = msg.content
+        .filter((part) => part.type === 'text')
+        .map((part) => part.text.value);
+      const content = textContents.length <= 1 ? textContents[0] || '' : textContents;
+      return { role: msg.role, content };
+    });
+  }
+
+  async create(code, context = {}) {
+    this._ensureClient();
+    this.status = 'active';
+
+    const whatsappId = context?.whatsapp_id || code;
+    if (whatsappId) {
+      this.lastMessages = await getLastNMessages(whatsappId, 20);
+    }
+
+    const initialMessages = await this.buildInitialMessages({ code, context });
+    const threadPayload = {};
+
+    if (initialMessages.length > 0) {
+      threadPayload.messages = initialMessages.map((msg) => ({
+        role: msg.role || 'assistant',
+        content: msg.content
+      }));
+    }
+
+    const thread = await this.client.beta.threads.create(threadPayload);
+    this.thread = thread;
+    return thread;
+  }
+
+  async buildInitialMessages({ code }) {
+    if (!this.lastMessages) return [];
+    return [{
+      role: 'assistant',
+      content: `Últimos mensajes para ${code}:
+${this.lastMessages}`
+    }];
+  }
+
+  async handleRequiresAction(run) {
+    const toolCalls = run?.required_action?.submit_tool_outputs?.tool_calls || [];
+    if (toolCalls.length === 0) {
+      return [];
+    }
+
+    const outputs = [];
+
+    for (const call of toolCalls) {
+      try {
+        const name = call.function?.name;
+        const args = call.function?.arguments ? JSON.parse(call.function.arguments) : {};
+        const result = await this.executeTool(name, args);
+        outputs.push({ tool_call_id: call.id, output: typeof result === 'string' ? result : JSON.stringify(result) });
+      } catch (error) {
+        console.error('[BaseAssistant] Tool execution failed', error);
+        outputs.push({
+          tool_call_id: call.id,
+          output: JSON.stringify({ success: false, error: error?.message || 'Tool execution failed' })
+        });
+      }
+    }
+
+    if (!this.client) {
+      console.warn('[BaseAssistant] Cannot submit tool outputs: client not configured');
+      return outputs;
+    }
+
+    await this.client.beta.threads.runs.submitToolOutputs(
+      run.thread_id,
+      run.id,
+      { tool_outputs: outputs }
+    );
+
+    return outputs;
+  }
+
+  async close() {
+    this.status = 'closed';
+    if (this.thread?.code && this.thread?.assistant_id) {
+      await Thread.updateOne(
+        { code: this.thread.code, assistant_id: this.thread.assistant_id },
+        { $set: { active: false } }
+      );
+    }
+
+    if (this.assistantId) {
+      console.log(`Assistant ${this.assistantId} closed`);
+    }
+
+    return `Assistant ${this.assistantId || ''} successfully closed.`.trim();
+  }
+}
+
+module.exports = {
+  BaseAssistant
+};

package/lib/assistants/index.js

@@ -0,0 +1,5 @@
+const { BaseAssistant } = require('./BaseAssistant');
+
+module.exports = {
+  BaseAssistant
+};

package/lib/index.d.ts

@@ -117,6 +117,48 @@ declare module '@peopl-health/nexus' {
     onFlow?: FlowHandler;
   }
 
+  export interface AssistantToolDefinition {
+    name: string;
+    description?: string;
+    parameters?: any;
+    handler: (args: any) => any;
+  }
+
+  export interface AssistantConfigDefinition {
+    extends?: typeof BaseAssistant;
+    create?: (this: BaseAssistant, code: string, context?: any) => Promise<any>;
+    tools?: Array<AssistantToolDefinition | { name: string; definition?: any; handler: (args: any) => any }>;
+    setup?: (this: BaseAssistant, context: { assistantId: string; thread?: any; options?: any }) => void;
+  }
+
+  export class BaseAssistant {
+    constructor(options?: {
+      assistantId?: string;
+      thread?: any;
+      client?: any;
+      tools?: Array<AssistantToolDefinition | { name: string; definition?: any; handler: (args: any) => any }>;
+      setup?: (context: { assistantId: string; thread?: any; options?: any }) => void;
+      status?: string;
+    } | any);
+    assistantId: string | null;
+    thread: any;
+    status: string;
+    createdAt: Date;
+    registerTool(definition: AssistantToolDefinition | string, schema?: any, handler?: (args: any) => any): void;
+    getToolSchemas(): any[];
+    executeTool(name: string, args: any): Promise<any>;
+    getPreviousMessages(thread?: any): Promise<Array<{ role: string; content: any }>>;
+    createThread(code: string, context?: any): Promise<any>;
+    sendMessage(userId: string, message: string, options?: any): Promise<any>;
+    waitForCompletion(threadId: string, runId: string, opts?: { interval?: number; maxAttempts?: number }): Promise<any>;
+    create(code: string, context?: any): Promise<any>;
+    buildInitialMessages(context: { code: string; [key: string]: any }): Promise<Array<{ role: string; content: string }>>;
+    handleRequiresAction(run: any): Promise<any[]>;
+    close(): Promise<string>;
+    setThread(thread: any): void;
+    setReplies(replies: any): void;
+  }
+
   // Core Classes
   export abstract class MessageProvider {
     constructor(config: any);
@@ -127,6 +169,15 @@ declare module '@peopl-health/nexus' {
     abstract disconnect(): Promise<void>;
   }
 
+  export function registerAssistant(
+    assistantId: string,
+    definition: typeof BaseAssistant | ((thread?: any) => any) | AssistantConfigDefinition
+  ): any;
+
+  export function configureAssistantsLLM(client: any): void;
+  export function overrideGetAssistantById(resolver: (assistantId: string, thread?: any) => any): void;
+  export function configureAssistants(config: any): void;
+
   export class TwilioProvider extends MessageProvider {
     constructor(config: TwilioConfig);
     initialize(): Promise<void>;

package/lib/index.js

@@ -16,6 +16,7 @@ const {
 } = require('./services/assistantService');
 const { TwilioProvider } = require('./adapters/TwilioProvider');
 const { BaileysProvider } = require('./adapters/BaileysProvider');
+const { BaseAssistant: CoreBaseAssistant } = require('./assistants/BaseAssistant');
 
 /**
  * Main Nexus class that orchestrates all components
@@ -312,6 +313,11 @@ module.exports = {
   MongoStorage,
   MessageParser,
   DefaultLLMProvider,
+  BaseAssistant: CoreBaseAssistant,
+  registerAssistant,
+  configureAssistantsLLM,
+  overrideGetAssistantById,
+  configureAssistants: setAssistantsConfig,
   routes,
   setupDefaultRoutes: routes.setupDefaultRoutes,
   createRouter: routes.createRouter,

package/lib/services/assistantService.js

@@ -3,6 +3,8 @@ const AWS = require('../config/awsConfig.js');
 const { combineImagesToPDF, cleanupFiles } = require('../helpers/filesHelper.js');
 const { addRecord } = require('../services/airtableService.js');
 const runtimeConfig = require('../config/runtimeConfig');
+const llmConfig = require('../config/llmConfig');
+const { BaseAssistant } = require('../assistants/BaseAssistant');
 
 let llmProvider = null;
 const configureLLMProvider = (provider) => {
@@ -27,8 +29,54 @@ const configureAssistants = (config) => {
   assistantConfig = config;
 };
 
-const registerAssistant = (assistantId, AssistantClass) => {
-  assistantRegistry[assistantId] = AssistantClass;
+const registerAssistant = (assistantId, definition) => {
+  if (!assistantId || typeof assistantId !== 'string') {
+    throw new Error('registerAssistant requires a string assistantId');
+  }
+
+  if (typeof definition === 'function') {
+    assistantRegistry[assistantId] = definition;
+    return definition;
+  }
+
+  if (definition && typeof definition === 'object') {
+    const {
+      extends: ParentClass = BaseAssistant,
+      create,
+      tools = [],
+      setup
+    } = definition;
+
+    class ConfiguredAssistant extends ParentClass {
+      constructor(options = {}) {
+        super({
+          ...options,
+          assistantId,
+          client: options.client || llmProvider || llmConfig.openaiClient || null,
+          tools: [...tools, ...(options.tools || [])]
+        });
+
+        if (typeof setup === 'function') {
+          setup.call(this, {
+            assistantId,
+            thread: this.thread,
+            options
+          });
+        }
+      }
+    }
+
+    if (typeof create === 'function') {
+      ConfiguredAssistant.prototype.create = async function(code, context) {
+        return await create.call(this, code, context);
+      };
+    }
+
+    assistantRegistry[assistantId] = ConfiguredAssistant;
+    return ConfiguredAssistant;
+  }
+
+  throw new Error('registerAssistant expects a class/function or configuration object');
 };
 
 const overrideGetAssistantById = (resolverFn) => {
@@ -51,8 +99,22 @@ const getAssistantById = (assistant_id, thread) => {
   if (!AssistantClass) {
     throw new Error(`Assistant '${assistant_id}' not found. Available assistants: ${Object.keys(assistantRegistry).join(', ')}`);
   }
-  
-  return new AssistantClass(thread);
+
+  const sharedClient = llmProvider || llmConfig.openaiClient || null;
+
+  if (AssistantClass.prototype instanceof BaseAssistant) {
+    return new AssistantClass({
+      assistantId: assistant_id,
+      thread,
+      client: sharedClient
+    });
+  }
+
+  try {
+    return new AssistantClass(thread);
+  } catch (error) {
+    return new AssistantClass({ thread, assistantId: assistant_id, client: sharedClient });
+  }
 };
 
 

package/package.json

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