@toothfairyai/cli 1.1.1 → 1.1.3

package/src/api.js

@@ -1,6 +1,6 @@
-const axios = require("axios");
-const fs = require("fs");
-const path = require("path");
+const axios = require('axios');
+const fs = require('fs');
+const path = require('path');
 
 class ToothFairyAPI {
   constructor(
@@ -17,8 +17,8 @@ class ToothFairyAPI {
     this.workspaceId = workspaceId;
     this.verbose = verbose;
     this.headers = {
-      "Content-Type": "application/json",
-      "x-api-key": apiKey,
+      'Content-Type': 'application/json',
+      'x-api-key': apiKey,
     };
   }
 
@@ -29,20 +29,20 @@ class ToothFairyAPI {
       headers: this.headers,
     };
 
-    if (method === "POST" || method === "PUT") {
+    if (method === 'POST' || method === 'PUT') {
       if (data) {
         data = { workspaceid: this.workspaceId, ...data };
       }
       config.data = data;
-    } else if (method === "GET" && data) {
+    } else if (method === 'GET' && data) {
       // For GET requests with data, add as query parameters
       const params = new URLSearchParams(data);
       config.url += `?${params.toString()}`;
     }
 
     if (this.verbose) {
-      const chalk = require("chalk");
-      console.error(chalk.dim("\n--- API Request Debug ---"));
+      const chalk = require('chalk');
+      console.error(chalk.dim('\n--- API Request Debug ---'));
       console.error(chalk.dim(`Method: ${method}`));
       console.error(chalk.dim(`URL: ${config.url}`));
       console.error(
@@ -53,15 +53,15 @@ class ToothFairyAPI {
           chalk.dim(`Data: ${JSON.stringify(config.data, null, 2)}`)
         );
       }
-      console.error(chalk.dim("----------------------\n"));
+      console.error(chalk.dim('----------------------\n'));
     }
 
     try {
       const response = await axios(config);
 
       if (this.verbose) {
-        const chalk = require("chalk");
-        console.error(chalk.dim("\n--- API Response Debug ---"));
+        const chalk = require('chalk');
+        console.error(chalk.dim('\n--- API Response Debug ---'));
         console.error(
           chalk.dim(`Status: ${response.status} ${response.statusText}`)
         );
@@ -73,14 +73,14 @@ class ToothFairyAPI {
         console.error(
           chalk.dim(`Response Data: ${JSON.stringify(response.data, null, 2)}`)
         );
-        console.error(chalk.dim("------------------------\n"));
+        console.error(chalk.dim('------------------------\n'));
       }
 
       return response.data;
     } catch (error) {
       if (this.verbose) {
-        const chalk = require("chalk");
-        console.error(chalk.red("\n--- API Error Debug ---"));
+        const chalk = require('chalk');
+        console.error(chalk.red('\n--- API Error Debug ---'));
         console.error(chalk.red(`Error: ${error.message}`));
         if (error.response) {
           console.error(
@@ -110,13 +110,13 @@ class ToothFairyAPI {
             )
           );
         }
-        console.error(chalk.red("---------------------\n"));
+        console.error(chalk.red('---------------------\n'));
       }
 
       if (error.response) {
         throw new Error(
           `HTTP ${error.response.status}: ${
-            error.response.data.message || "API request failed"
+            error.response.data.message || 'API request failed'
           }`
         );
       }
@@ -125,39 +125,39 @@ class ToothFairyAPI {
   }
 
   async createChat(chatData) {
-    return this._makeRequest("POST", "chat/create", chatData);
+    return this._makeRequest('POST', 'chat/create', chatData);
   }
 
   async updateChat(chatData) {
-    return this._makeRequest("POST", "chat/update", chatData);
+    return this._makeRequest('POST', 'chat/update', chatData);
   }
 
   async getChat(chatId) {
-    return this._makeRequest("GET", `chat/get/${chatId}`);
+    return this._makeRequest('GET', `chat/get/${chatId}`);
   }
 
   async createMessage(messageData) {
-    return this._makeRequest("POST", "chat_message/create", messageData);
+    return this._makeRequest('POST', 'chat_message/create', messageData);
   }
 
   async getMessage(messageId) {
-    return this._makeRequest("GET", `chat_message/get/${messageId}`);
+    return this._makeRequest('GET', `chat_message/get/${messageId}`);
   }
 
   async getAllChats() {
-    return this._makeRequest("GET", "chat/list", {
+    return this._makeRequest('GET', 'chat/list', {
       workspaceid: this.workspaceId,
     });
   }
   async getAllMessagesByChat(chatid) {
-    return this._makeRequest("GET", "chat_message/by_chat", {
+    return this._makeRequest('GET', 'chat_message/by_chat', {
       chatid: chatid,
     });
   }
 
   async getAgentResponse(agentData) {
     const config = {
-      method: "POST",
+      method: 'POST',
       url: `${this.aiUrl}/chatter`,
       headers: this.headers,
       data: { workspaceid: this.workspaceId, ...agentData },
@@ -170,7 +170,7 @@ class ToothFairyAPI {
       if (error.response) {
         throw new Error(
           `HTTP ${error.response.status}: ${
-            error.response.data.message || "Agent request failed"
+            error.response.data.message || 'Agent request failed'
           }`
         );
       }
@@ -185,7 +185,8 @@ class ToothFairyAPI {
     customerId = null,
     providerId = null,
     customerInfo = {},
-    attachments = {}
+    attachments = {},
+    chatId = null
   ) {
     try {
       // Use defaults for optional parameters
@@ -193,66 +194,96 @@ class ToothFairyAPI {
         customerId ||
         `cli-user-${
           Math.abs(
-            message.split("").reduce((a, b) => {
+            message.split('').reduce((a, b) => {
               a = (a << 5) - a + b.charCodeAt(0);
               return a & a;
             }, 0)
           ) % 10000
         }`;
-      phoneNumber = phoneNumber || "+1234567890";
-      providerId = providerId || "default-sms-provider";
+      phoneNumber = phoneNumber || '+1234567890';
+      providerId = providerId || 'default-sms-provider';
 
       // Process file attachments if provided
       const processedAttachments = await this._processAttachments(attachments);
 
-      const chatData = {
-        name: customerId,
-        primaryRole: agentId,
-        externalParticipantId: phoneNumber,
-        channelSettings: {
-          sms: {
-            isEnabled: true,
-            recipient: phoneNumber,
-            providerID: providerId,
-          },
-        },
-        customerId: customerId,
-        customerInfo: customerInfo,
-        isAIReplying: true,
-      };
+      if (chatId) {
+        // Use existing chat - let REST endpoint handle message creation
+        const messageData = {
+          text: message,
+          role: 'user',
+          userID: 'CLI',
+        };
 
-      const createdChat = await this.createChat(chatData);
-      // console.log(`Chat created: ${createdChat.id}`);
+        // Only include attachment fields if they have content
+        if (processedAttachments.images && processedAttachments.images.length > 0) {
+          messageData.images = processedAttachments.images;
+        }
+        if (processedAttachments.audios && processedAttachments.audios.length > 0) {
+          messageData.audios = processedAttachments.audios;
+        }
+        if (processedAttachments.videos && processedAttachments.videos.length > 0) {
+          messageData.videos = processedAttachments.videos;
+        }
+        if (processedAttachments.files && processedAttachments.files.length > 0) {
+          messageData.files = processedAttachments.files;
+        }
 
-      const messageData = {
-        chatID: createdChat.id,
-        text: message,
-        role: "user",
-        userID: "CLI",
-        ...processedAttachments,
-      };
-      const createdMessage = await this.createMessage(messageData);
-      // console.log(`Message created: ${createdMessage.id}`);;
+        const agentData = {
+          chatid: chatId,
+          messages: [messageData],
+          agentid: agentId,
+        };
+        
+        const agentResponse = await this.getAgentResponse(agentData);
+        
+        return {
+          chatId: agentResponse.chatId || chatId,
+          messageId: agentResponse.messageId || 'auto-generated',
+          agentResponse: agentResponse,
+        };
+      } else {
+        // No chatId provided - let API create chat automatically
+        // Prepare message data for automatic chat creation
+        const messageData = {
+          text: message,
+          role: 'user',
+          userID: customerId,
+        };
 
-      const agentData = {
-        chatid: createdChat.id,
-        messages: [
-          {
-            text: createdMessage.text,
-            role: createdMessage.role,
-            userID: createdMessage.userID || "System User",
-          },
-        ],
-        agentid: agentId,
-      };
-      const agentResponse = await this.getAgentResponse(agentData);
-      // console.log('Agent response received');
+        // Only include attachment fields if they have content
+        if (processedAttachments.images && processedAttachments.images.length > 0) {
+          messageData.images = processedAttachments.images;
+        }
+        if (processedAttachments.audios && processedAttachments.audios.length > 0) {
+          messageData.audios = processedAttachments.audios;
+        }
+        if (processedAttachments.videos && processedAttachments.videos.length > 0) {
+          messageData.videos = processedAttachments.videos;
+        }
+        if (processedAttachments.files && processedAttachments.files.length > 0) {
+          messageData.files = processedAttachments.files;
+        }
 
-      return {
-        chatId: createdChat.id,
-        messageId: createdMessage.id,
-        agentResponse: agentResponse,
-      };
+        // Send agent request without chatid - API will create chat and message automatically
+        const agentData = {
+          // No chatid - let API create the chat
+          messages: [messageData],
+          agentid: agentId,
+          // Include chat creation data since we're not pre-creating
+          phoneNumber: phoneNumber,
+          customerId: customerId,
+          providerId: providerId,
+          customerInfo: customerInfo,
+        };
+        
+        const agentResponse = await this.getAgentResponse(agentData);
+        
+        return {
+          chatId: agentResponse.chatId || 'auto-generated',
+          messageId: agentResponse.messageId || 'auto-generated', 
+          agentResponse: agentResponse,
+        };
+      }
     } catch (error) {
       console.error(`Error in sendMessageToAgent: ${error.message}`);
       throw error;
@@ -261,7 +292,7 @@ class ToothFairyAPI {
 
   async searchDocuments(text, topK = 10, metadata = null) {
     if (topK < 1 || topK > 50) {
-      throw new Error("topK must be between 1 and 50");
+      throw new Error('topK must be between 1 and 50');
     }
 
     const searchData = {
@@ -274,7 +305,7 @@ class ToothFairyAPI {
     }
 
     const config = {
-      method: "POST",
+      method: 'POST',
       url: `${this.aiUrl}/searcher`,
       headers: this.headers,
       data: { workspaceid: this.workspaceId, ...searchData },
@@ -287,7 +318,7 @@ class ToothFairyAPI {
       if (error.response) {
         throw new Error(
           `HTTP ${error.response.status}: ${
-            error.response.data.message || "Search request failed"
+            error.response.data.message || 'Search request failed'
           }`
         );
       }
@@ -329,7 +360,7 @@ class ToothFairyAPI {
    * - 'sse_event': All raw SSE events (only when showProgress=true)
    *
    * The onEvent callback receives: (eventType, eventData) => {}
-   * 
+   *
    * When showProgress is true, all SSE events will be emitted to the onEvent callback
    * with the 'sse_event' type, providing access to all raw events from the streaming
    * endpoint, similar to the CLI's --show-progress flag behavior.
@@ -343,7 +374,8 @@ class ToothFairyAPI {
     customerInfo = {},
     onEvent,
     attachments = {},
-    showProgress = false
+    showProgress = false,
+    chatId = null
   ) {
     try {
       // Use defaults for optional parameters
@@ -351,207 +383,374 @@ class ToothFairyAPI {
         customerId ||
         `cli-user-${
           Math.abs(
-            message.split("").reduce((a, b) => {
+            message.split('').reduce((a, b) => {
               a = (a << 5) - a + b.charCodeAt(0);
               return a & a;
             }, 0)
           ) % 10000
         }`;
-      phoneNumber = phoneNumber || "+1234567890";
-      providerId = providerId || "default-sms-provider";
+      phoneNumber = phoneNumber || '+1234567890';
+      providerId = providerId || 'default-sms-provider';
 
       // Process file attachments if provided
       const processedAttachments = await this._processAttachments(attachments);
 
-      // Create chat first
-      const chatData = {
-        name: customerId,
-        primaryRole: agentId,
-        externalParticipantId: phoneNumber,
-        channelSettings: {
-          sms: {
-            isEnabled: true,
-            recipient: phoneNumber,
-            providerID: providerId,
-          },
-        },
-        customerId: customerId,
-        customerInfo: customerInfo,
-        isAIReplying: true,
-      };
+      if (chatId) {
+        // Use existing chat - let SSE endpoint handle message creation
+        if (this.verbose) {
+          console.debug(`Using existing chat: ${chatId}`);
+        }
 
-      const createdChat = await this.createChat(chatData);
-      if (this.verbose) {
-        console.debug(`Chat created: ${createdChat.id}`);
-      }
+        const messageData = {
+          text: message,
+          role: 'user',
+          userID: 'CLI',
+        };
 
-      // Create message
-      const messageData = {
-        chatID: createdChat.id,
-        text: message,
-        role: "user",
-        userID: "CLI",
-        ...processedAttachments,
-      };
-      const createdMessage = await this.createMessage(messageData);
-      if (this.verbose) {
-        console.debug(`Message created: ${createdMessage.id}`);
-      }
+        // Only include attachment fields if they have content
+        if (processedAttachments.images && processedAttachments.images.length > 0) {
+          messageData.images = processedAttachments.images;
+        }
+        if (processedAttachments.audios && processedAttachments.audios.length > 0) {
+          messageData.audios = processedAttachments.audios;
+        }
+        if (processedAttachments.videos && processedAttachments.videos.length > 0) {
+          messageData.videos = processedAttachments.videos;
+        }
+        if (processedAttachments.files && processedAttachments.files.length > 0) {
+          messageData.files = processedAttachments.files;
+        }
 
-      // Prepare agent data for streaming
-      const agentData = {
-        workspaceid: this.workspaceId,
-        messages: [
-          {
-            text: createdMessage.text,
-            role: createdMessage.role,
-            userID: createdMessage.userID || "System User",
-          },
-        ],
-        agentid: agentId,
-      };
+        // Prepare agent data for streaming with existing chat
+        const agentData = {
+          workspaceid: this.workspaceId,
+          chatid: chatId,
+          messages: [messageData],
+          agentid: agentId,
+        };
 
-      // Stream the agent response using the dedicated streaming URL
-      const streamUrl = `${this.aiStreamUrl}/agent`; // Using streaming URL for /agent endpoint
+        // Stream the agent response using the dedicated streaming URL
+        const streamUrl = `${this.aiStreamUrl}/agent`;
+
+        return new Promise((resolve, reject) => {
+          // For POST requests with EventSource, we need to use a different approach
+          // EventSource doesn't support POST requests directly, so we'll use axios with streaming
+          const config = {
+            method: 'POST',
+            url: streamUrl,
+            headers: {
+              ...this.headers,
+              Accept: 'text/event-stream',
+              'Cache-Control': 'no-cache',
+            },
+            data: agentData,
+            responseType: 'stream',
+            timeout: 300000, // 5 minute timeout
+          };
+
+          axios(config)
+            .then((response) => {
+              let buffer = '';
+
+              response.data.on('data', (chunk) => {
+                buffer += chunk.toString();
+
+                // Process complete lines
+                const lines = buffer.split('\n');
+                buffer = lines.pop() || ''; // Keep the incomplete line in buffer
+
+                for (const line of lines) {
+                  if (line.trim() === '') continue;
+
+                  if (line.startsWith('data: ')) {
+                    const dataStr = line.slice(6); // Remove 'data: ' prefix
+
+                    try {
+                      const eventData = JSON.parse(dataStr);
+
+                      // If showProgress is enabled, emit all events
+                      if (showProgress) {
+                        // Emit all events with their raw structure
+                        onEvent('sse_event', eventData);
+                      }
 
-      return new Promise((resolve, reject) => {
-        // For POST requests with EventSource, we need to use a different approach
-        // EventSource doesn't support POST requests directly, so we'll use axios with streaming
-        const config = {
-          method: "POST",
-          url: streamUrl,
-          headers: {
-            ...this.headers,
-            Accept: "text/event-stream",
-            "Cache-Control": "no-cache",
-          },
-          data: agentData,
-          responseType: "stream",
-          timeout: 300000, // 5 minute timeout
-        };
+                      // Standard event processing (always executed for backward compatibility)
+                      if (eventData.status) {
+                        if (eventData.status === 'connected') {
+                          onEvent('status', eventData);
+                        } else if (eventData.status === 'complete') {
+                          onEvent('status', eventData);
+                        } else if (eventData.status === 'inProgress') {
+                          // Parse metadata to understand what's happening
+                          let metadata = {};
+                          if (eventData.metadata) {
+                            try {
+                              metadata = JSON.parse(eventData.metadata);
+                            } catch (e) {
+                              metadata = { raw_metadata: eventData.metadata };
+                            }
+                          }
 
-        axios(config)
-          .then((response) => {
-            let buffer = "";
+                          // Determine progress type
+                          if (metadata.agent_processing_status) {
+                            const processingStatus =
+                              metadata.agent_processing_status;
+                            onEvent('progress', {
+                              ...eventData,
+                              processing_status: processingStatus,
+                              metadata_parsed: metadata,
+                            });
+                          } else {
+                            onEvent('progress', {
+                              ...eventData,
+                              metadata_parsed: metadata,
+                            });
+                          }
+                        } else if (eventData.status === 'fulfilled') {
+                          // Final response with complete data
+                          onEvent('complete', eventData);
+                        }
+                      } else if (eventData.text && eventData.type === 'message') {
+                        // This is streaming text data
+                        onEvent('data', eventData);
+                      } else if (
+                        eventData.type === 'message' &&
+                        eventData.images !== undefined
+                      ) {
+                        // Additional message metadata (images, files, etc.)
+                        onEvent('metadata', eventData);
+                      } else if (
+                        eventData.type === 'message' &&
+                        eventData.callbackMetadata
+                      ) {
+                        // Callback metadata with function details and execution plan
+                        onEvent('callback', eventData);
+                      } else if (eventData.type === 'chat_created' || eventData.event === 'chat_created') {
+                        // Chat creation event
+                        onEvent('chat_created', eventData);
+                      } else {
+                        // Generic event data
+                        onEvent('unknown', eventData);
+                      }
+                    } catch (e) {
+                      console.error(
+                        `Failed to parse SSE data: ${dataStr}, error: ${e.message}`
+                      );
+                      onEvent('error', {
+                        error: 'json_decode_error',
+                        raw_data: dataStr,
+                        message: e.message,
+                      });
+                    }
+                  }
+                }
+              });
 
-            response.data.on("data", (chunk) => {
-              buffer += chunk.toString();
+              response.data.on('end', () => {
+                resolve();
+              });
 
-              // Process complete lines
-              const lines = buffer.split("\n");
-              buffer = lines.pop() || ""; // Keep the incomplete line in buffer
+              response.data.on('error', (error) => {
+                onEvent('error', {
+                  error: 'stream_error',
+                  message: error.message,
+                });
+                reject(error);
+              });
+            })
+            .catch((error) => {
+              onEvent('error', {
+                error: 'request_error',
+                message: error.message,
+              });
+              reject(error);
+            });
+        });
+      } else {
+        // No chatId provided - let streaming API create chat automatically
+        if (this.verbose) {
+          console.debug('No chatId provided - letting API create chat automatically');
+        }
 
-              for (const line of lines) {
-                if (line.trim() === "") continue;
+        // Prepare message data for automatic chat creation
+        const messageData = {
+          text: message,
+          role: 'user',
+          userID: customerId,
+        };
 
-                if (line.startsWith("data: ")) {
-                  const dataStr = line.slice(6); // Remove 'data: ' prefix
+        // Only include attachment fields if they have content
+        if (processedAttachments.images && processedAttachments.images.length > 0) {
+          messageData.images = processedAttachments.images;
+        }
+        if (processedAttachments.audios && processedAttachments.audios.length > 0) {
+          messageData.audios = processedAttachments.audios;
+        }
+        if (processedAttachments.videos && processedAttachments.videos.length > 0) {
+          messageData.videos = processedAttachments.videos;
+        }
+        if (processedAttachments.files && processedAttachments.files.length > 0) {
+          messageData.files = processedAttachments.files;
+        }
 
-                  try {
-                    const eventData = JSON.parse(dataStr);
+        // Send agent request without chatid - API will create chat and message automatically
+        const agentData = {
+          workspaceid: this.workspaceId,
+          // No chatid - let API create the chat
+          messages: [messageData],
+          agentid: agentId,
+          // Include chat creation data since we're not pre-creating
+          phoneNumber: phoneNumber,
+          customerId: customerId,
+          providerId: providerId,
+          customerInfo: customerInfo,
+        };
 
-                    // If showProgress is enabled, emit all events
-                    if (showProgress) {
-                      // Emit all events with their raw structure
-                      onEvent('sse_event', eventData);
-                    }
+        // Stream the agent response using the dedicated streaming URL
+        const streamUrl = `${this.aiStreamUrl}/agent`;
+
+        return new Promise((resolve, reject) => {
+          // For POST requests with EventSource, we need to use a different approach
+          // EventSource doesn't support POST requests directly, so we'll use axios with streaming
+          const config = {
+            method: 'POST',
+            url: streamUrl,
+            headers: {
+              ...this.headers,
+              Accept: 'text/event-stream',
+              'Cache-Control': 'no-cache',
+            },
+            data: agentData,
+            responseType: 'stream',
+            timeout: 300000, // 5 minute timeout
+          };
+
+          axios(config)
+            .then((response) => {
+              let buffer = '';
+
+              response.data.on('data', (chunk) => {
+                buffer += chunk.toString();
+
+                // Process complete lines
+                const lines = buffer.split('\n');
+                buffer = lines.pop() || ''; // Keep the incomplete line in buffer
+
+                for (const line of lines) {
+                  if (line.trim() === '') continue;
+
+                  if (line.startsWith('data: ')) {
+                    const dataStr = line.slice(6); // Remove 'data: ' prefix
+
+                    try {
+                      const eventData = JSON.parse(dataStr);
+
+                      // If showProgress is enabled, emit all events
+                      if (showProgress) {
+                        // Emit all events with their raw structure
+                        onEvent('sse_event', eventData);
+                      }
 
-                    // Standard event processing (always executed for backward compatibility)
-                    if (eventData.status) {
-                      if (eventData.status === 'connected') {
-                        onEvent('status', eventData);
-                      } else if (eventData.status === 'complete') {
-                        onEvent('status', eventData);
-                      } else if (eventData.status === 'inProgress') {
-                        // Parse metadata to understand what's happening
-                        let metadata = {};
-                        if (eventData.metadata) {
-                          try {
-                            metadata = JSON.parse(eventData.metadata);
-                          } catch (e) {
-                            metadata = { raw_metadata: eventData.metadata };
+                      // Standard event processing (always executed for backward compatibility)
+                      if (eventData.status) {
+                        if (eventData.status === 'connected') {
+                          onEvent('status', eventData);
+                        } else if (eventData.status === 'complete') {
+                          onEvent('status', eventData);
+                        } else if (eventData.status === 'inProgress') {
+                          // Parse metadata to understand what's happening
+                          let metadata = {};
+                          if (eventData.metadata) {
+                            try {
+                              metadata = JSON.parse(eventData.metadata);
+                            } catch (e) {
+                              metadata = { raw_metadata: eventData.metadata };
+                            }
                           }
-                        }
 
-                        // Determine progress type
-                        if (metadata.agent_processing_status) {
-                          const processingStatus =
-                            metadata.agent_processing_status;
-                          onEvent('progress', {
-                            ...eventData,
-                            processing_status: processingStatus,
-                            metadata_parsed: metadata,
-                          });
-                        } else {
-                          onEvent('progress', {
-                            ...eventData,
-                            metadata_parsed: metadata,
-                          });
+                          // Determine progress type
+                          if (metadata.agent_processing_status) {
+                            const processingStatus =
+                              metadata.agent_processing_status;
+                            onEvent('progress', {
+                              ...eventData,
+                              processing_status: processingStatus,
+                              metadata_parsed: metadata,
+                            });
+                          } else {
+                            onEvent('progress', {
+                              ...eventData,
+                              metadata_parsed: metadata,
+                            });
+                          }
+                        } else if (eventData.status === 'fulfilled') {
+                          // Final response with complete data
+                          onEvent('complete', eventData);
                         }
-                      } else if (eventData.status === 'fulfilled') {
-                        // Final response with complete data
-                        onEvent('complete', eventData);
+                      } else if (eventData.text && eventData.type === 'message') {
+                        // This is streaming text data
+                        onEvent('data', eventData);
+                      } else if (
+                        eventData.type === 'message' &&
+                        eventData.images !== undefined
+                      ) {
+                        // Additional message metadata (images, files, etc.)
+                        onEvent('metadata', eventData);
+                      } else if (
+                        eventData.type === 'message' &&
+                        eventData.callbackMetadata
+                      ) {
+                        // Callback metadata with function details and execution plan
+                        onEvent('callback', eventData);
+                      } else if (
+                        eventData.type === 'chat_created' ||
+                        eventData.event === 'chat_created'
+                      ) {
+                        // Chat creation event
+                        onEvent('chat_created', eventData);
+                      } else {
+                        // Generic event data
+                        onEvent('unknown', eventData);
                       }
-                    } else if (eventData.text && eventData.type === 'message') {
-                      // This is streaming text data
-                      onEvent('data', eventData);
-                    } else if (
-                      eventData.type === 'message' &&
-                      eventData.images !== undefined
-                    ) {
-                      // Additional message metadata (images, files, etc.)
-                      onEvent('metadata', eventData);
-                    } else if (
-                      eventData.type === 'message' &&
-                      eventData.callbackMetadata
-                    ) {
-                      // Callback metadata with function details and execution plan
-                      onEvent('callback', eventData);
-                    } else if (eventData.type === 'chat_created' || eventData.event === 'chat_created') {
-                      // Chat creation event
-                      onEvent('chat_created', eventData);
-                    } else {
-                      // Generic event data
-                      onEvent('unknown', eventData);
+                    } catch (e) {
+                      console.error(
+                        `Failed to parse SSE data: ${dataStr}, error: ${e.message}`
+                      );
+                      onEvent('error', {
+                        error: 'json_decode_error',
+                        raw_data: dataStr,
+                        message: e.message,
+                      });
                     }
-                  } catch (e) {
-                    console.error(
-                      `Failed to parse SSE data: ${dataStr}, error: ${e.message}`
-                    );
-                    onEvent("error", {
-                      error: "json_decode_error",
-                      raw_data: dataStr,
-                      message: e.message,
-                    });
                   }
                 }
-              }
-            });
+              });
 
-            response.data.on("end", () => {
-              resolve();
-            });
+              response.data.on('end', () => {
+                resolve();
+              });
 
-            response.data.on("error", (error) => {
-              onEvent("error", {
-                error: "stream_error",
+              response.data.on('error', (error) => {
+                onEvent('error', {
+                  error: 'stream_error',
+                  message: error.message,
+                });
+                reject(error);
+              });
+            })
+            .catch((error) => {
+              onEvent('error', {
+                error: 'request_error',
                 message: error.message,
               });
               reject(error);
             });
-          })
-          .catch((error) => {
-            onEvent("error", {
-              error: "request_error",
-              message: error.message,
-            });
-            reject(error);
-          });
-      });
+        });
+      }
     } catch (error) {
       console.error(`Error in sendMessageToAgentStream: ${error.message}`);
-      onEvent("error", {
-        error: "setup_error",
+      onEvent('error', {
+        error: 'setup_error',
         message: error.message,
       });
       throw error;
@@ -572,24 +771,24 @@ class ToothFairyAPI {
     });
 
     if (importType) {
-      params.append("importType", importType);
+      params.append('importType', importType);
     }
 
     if (contentType) {
-      params.append("contentType", contentType);
+      params.append('contentType', contentType);
     }
 
     const config = {
-      method: "GET",
+      method: 'GET',
       url: `${this.baseUrl}/documents/requestPreSignedURL?${params.toString()}`,
       headers: this.headers,
     };
 
     if (this.verbose) {
-      const chalk = require("chalk");
-      console.error(chalk.dim("\n--- Upload URL Request Debug ---"));
+      const chalk = require('chalk');
+      console.error(chalk.dim('\n--- Upload URL Request Debug ---'));
       console.error(chalk.dim(`URL: ${config.url}`));
-      console.error(chalk.dim("----------------------------\n"));
+      console.error(chalk.dim('----------------------------\n'));
     }
 
     try {
@@ -599,7 +798,7 @@ class ToothFairyAPI {
       if (error.response) {
         throw new Error(
           `HTTP ${error.response.status}: ${
-            error.response.data.message || "Upload URL request failed"
+            error.response.data.message || 'Upload URL request failed'
           }`
         );
       }
@@ -659,14 +858,14 @@ class ToothFairyAPI {
       finalContentType
     );
     if (this.verbose) {
-      const chalk = require("chalk");
-      console.error(chalk.dim("\n--- File Upload URL response ---"));
+      const chalk = require('chalk');
+      console.error(chalk.dim('\n--- File Upload URL response ---'));
       console.error(chalk.dim(`Raw response: ${JSON.stringify(uploadData)}`));
     }
 
     // Parse the nested response structure
     let parsedUploadData;
-    if (uploadData.body && typeof uploadData.body === "string") {
+    if (uploadData.body && typeof uploadData.body === 'string') {
       try {
         parsedUploadData = JSON.parse(uploadData.body);
       } catch (error) {
@@ -679,18 +878,18 @@ class ToothFairyAPI {
     }
 
     if (!parsedUploadData.uploadURL) {
-      throw new Error("Failed to get upload URL from server");
+      throw new Error('Failed to get upload URL from server');
     }
 
     // Upload file to S3
     const fileData = fs.readFileSync(filePath);
 
     const uploadConfig = {
-      method: "PUT",
+      method: 'PUT',
       url: parsedUploadData.uploadURL,
       data: fileData,
       headers: {
-        "Content-Type": finalContentType,
+        'Content-Type': finalContentType,
       },
       maxContentLength: Infinity,
       maxBodyLength: Infinity,
@@ -709,8 +908,8 @@ class ToothFairyAPI {
     };
 
     if (this.verbose) {
-      const chalk = require("chalk");
-      console.error(chalk.dim("\n--- File Upload Debug ---"));
+      const chalk = require('chalk');
+      console.error(chalk.dim('\n--- File Upload Debug ---'));
       console.error(chalk.dim(`File: ${filePath}`));
       console.error(chalk.dim(`Original filename: ${originalFilename}`));
       console.error(chalk.dim(`Sanitized filename: ${sanitizedFilename}`));
@@ -719,7 +918,7 @@ class ToothFairyAPI {
       console.error(chalk.dim(`Content type: ${finalContentType}`));
       console.error(chalk.dim(`Size: ${fileSizeInMB.toFixed(2)}MB`));
       console.error(chalk.dim(`Upload URL: ${parsedUploadData.uploadURL}`));
-      console.error(chalk.dim("------------------------\n"));
+      console.error(chalk.dim('------------------------\n'));
     }
 
     try {
@@ -731,7 +930,7 @@ class ToothFairyAPI {
         // Remove S3 bucket prefix from filePath to get clean filename for download
         downloadFilename = parsedUploadData.filePath.replace(
           /^s3:\/\/[^/]+\//,
-          ""
+          ''
         );
       }
 
@@ -749,7 +948,7 @@ class ToothFairyAPI {
       if (error.response) {
         throw new Error(
           `Upload failed: HTTP ${error.response.status}: ${
-            error.response.data?.message || "File upload failed"
+            error.response.data?.message || 'File upload failed'
           }`
         );
       }
@@ -765,7 +964,7 @@ class ToothFairyAPI {
    * @param {string} context - Context for the download (default: "pdf")
    * @returns {Promise<Object>} - Download URL and metadata
    */
-  async getDownloadUrl(filename, workspaceId, context = "pdf") {
+  async getDownloadUrl(filename, workspaceId, context = 'pdf') {
     const params = new URLSearchParams({
       filename: filename,
       context: context,
@@ -773,7 +972,7 @@ class ToothFairyAPI {
     });
 
     const config = {
-      method: "GET",
+      method: 'GET',
       url: `${
         this.baseUrl
       }/documents/requestDownloadURLIncognito?${params.toString()}`,
@@ -781,10 +980,10 @@ class ToothFairyAPI {
     };
 
     if (this.verbose) {
-      const chalk = require("chalk");
-      console.error(chalk.dim("\n--- Download URL Request Debug ---"));
+      const chalk = require('chalk');
+      console.error(chalk.dim('\n--- Download URL Request Debug ---'));
       console.error(chalk.dim(`URL: ${config.url}`));
-      console.error(chalk.dim("-----------------------------\n"));
+      console.error(chalk.dim('-----------------------------\n'));
     }
 
     try {
@@ -794,7 +993,7 @@ class ToothFairyAPI {
       if (error.response) {
         throw new Error(
           `HTTP ${error.response.status}: ${
-            error.response.data.message || "Download URL request failed"
+            error.response.data.message || 'Download URL request failed'
           }`
         );
       }
@@ -816,7 +1015,7 @@ class ToothFairyAPI {
     filename,
     workspaceId,
     outputPath,
-    context = "pdf",
+    context = 'pdf',
     onProgress = null
   ) {
     // Get download URL
@@ -827,7 +1026,7 @@ class ToothFairyAPI {
     );
 
     if (!downloadData.url) {
-      throw new Error("Failed to get download URL from server");
+      throw new Error('Failed to get download URL from server');
     }
 
     // Ensure output directory exists
@@ -838,9 +1037,9 @@ class ToothFairyAPI {
 
     // Download file
     const downloadConfig = {
-      method: "GET",
+      method: 'GET',
       url: downloadData.url,
-      responseType: "stream",
+      responseType: 'stream',
       onDownloadProgress: onProgress
         ? (progressEvent) => {
             if (progressEvent.total) {
@@ -858,11 +1057,11 @@ class ToothFairyAPI {
     };
 
     if (this.verbose) {
-      const chalk = require("chalk");
-      console.error(chalk.dim("\n--- File Download Debug ---"));
+      const chalk = require('chalk');
+      console.error(chalk.dim('\n--- File Download Debug ---'));
       console.error(chalk.dim(`Download URL: ${downloadData.url}`));
       console.error(chalk.dim(`Output Path: ${outputPath}`));
-      console.error(chalk.dim("---------------------------\n"));
+      console.error(chalk.dim('---------------------------\n'));
     }
 
     try {
@@ -873,7 +1072,7 @@ class ToothFairyAPI {
       response.data.pipe(writer);
 
       return new Promise((resolve, reject) => {
-        writer.on("finish", () => {
+        writer.on('finish', () => {
           const stats = fs.statSync(outputPath);
           resolve({
             success: true,
@@ -882,13 +1081,13 @@ class ToothFairyAPI {
             sizeInMB: (stats.size / (1024 * 1024)).toFixed(2),
           });
         });
-        writer.on("error", reject);
+        writer.on('error', reject);
       });
     } catch (error) {
       if (error.response) {
         throw new Error(
           `Download failed: HTTP ${error.response.status}: ${
-            error.response.data?.message || "File download failed"
+            error.response.data?.message || 'File download failed'
           }`
         );
       }
@@ -904,11 +1103,11 @@ class ToothFairyAPI {
    */
   _sanitizeFilename(filename) {
     // Remove non-alphanumeric characters except dots
-    let sanitized = filename.replace(/[^a-zA-Z0-9.]/g, "");
+    let sanitized = filename.replace(/[^a-zA-Z0-9.]/g, '');
 
     // Check length limit
     if (sanitized.length > 100) {
-      throw new Error("File name cannot be more than 100 characters.");
+      throw new Error('File name cannot be more than 100 characters.');
     }
 
     // Add timestamp prefix like frontend
@@ -927,20 +1126,20 @@ class ToothFairyAPI {
     const ext = path.extname(filePath).toLowerCase().slice(1);
 
     // Image extensions
-    const imageExts = ["png", "jpg", "jpeg", "gif", "bmp", "svg"];
+    const imageExts = ['png', 'jpg', 'jpeg', 'gif', 'bmp', 'svg'];
     // Video extensions
-    const videoExts = ["mp4", "avi", "mov", "wmv", "flv", "webm"];
+    const videoExts = ['mp4', 'avi', 'mov', 'wmv', 'flv', 'webm'];
     // Audio extensions
-    const audioExts = ["wav", "mp3", "aac", "ogg", "flac"];
+    const audioExts = ['wav', 'mp3', 'aac', 'ogg', 'flac'];
 
     if (imageExts.includes(ext)) {
-      return "imported-image";
+      return 'imported-image';
     } else if (videoExts.includes(ext)) {
-      return "imported_video_files";
+      return 'imported_video_files';
     } else if (audioExts.includes(ext)) {
-      return "imported_audio_files";
+      return 'imported_audio_files';
     } else {
-      return "imported_doc_files";
+      return 'imported_doc_files';
     }
   }
 
@@ -954,38 +1153,38 @@ class ToothFairyAPI {
     const ext = path.extname(filePath).toLowerCase().slice(1);
 
     const contentTypes = {
-      txt: "text/plain",
-      md: "text/markdown",
-      html: "text/html",
-      pdf: "application/pdf",
-      json: "application/json",
-      jsonl: "application/json",
-      wav: "audio/wav",
-      mp4: "video/mp4",
-      png: "image/png",
-      jpg: "image/jpeg",
-      jpeg: "image/jpeg",
-      csv: "text/csv",
-      docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-      xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-      pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
-      ppt: "application/vnd.ms-powerpoint",
-      java: "text/plain",
-      py: "text/plain",
-      js: "text/plain",
-      ts: "text/plain",
-      tsx: "text/plain",
-      jsx: "text/plain",
-      yaml: "text/plain",
-      yml: "text/plain",
-      sql: "text/plain",
-      sh: "text/plain",
-      php: "text/plain",
-      csharp: "text/plain",
-      rb: "text/plain",
+      txt: 'text/plain',
+      md: 'text/markdown',
+      html: 'text/html',
+      pdf: 'application/pdf',
+      json: 'application/json',
+      jsonl: 'application/json',
+      wav: 'audio/wav',
+      mp4: 'video/mp4',
+      png: 'image/png',
+      jpg: 'image/jpeg',
+      jpeg: 'image/jpeg',
+      csv: 'text/csv',
+      docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+      xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+      pptx: 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+      ppt: 'application/vnd.ms-powerpoint',
+      java: 'text/plain',
+      py: 'text/plain',
+      js: 'text/plain',
+      ts: 'text/plain',
+      tsx: 'text/plain',
+      jsx: 'text/plain',
+      yaml: 'text/plain',
+      yml: 'text/plain',
+      sql: 'text/plain',
+      sh: 'text/plain',
+      php: 'text/plain',
+      csharp: 'text/plain',
+      rb: 'text/plain',
     };
 
-    return contentTypes[ext] || "application/octet-stream";
+    return contentTypes[ext] || 'application/octet-stream';
   }
 
   /**
@@ -996,18 +1195,18 @@ class ToothFairyAPI {
    */
   _getDocumentType(filePath) {
     // Check if it's a URL
-    if (filePath.startsWith("http://") || filePath.startsWith("https://")) {
-      return "readComprehensionUrl";
+    if (filePath.startsWith('http://') || filePath.startsWith('https://')) {
+      return 'readComprehensionUrl';
     }
 
     // Check if it's a PDF file
     const ext = path.extname(filePath).toLowerCase().slice(1);
-    if (ext === "pdf") {
-      return "readComprehensionPdf";
+    if (ext === 'pdf') {
+      return 'readComprehensionPdf';
     }
 
     // For all other file types (Excel, CSV, etc.)
-    return "readComprehensionFile";
+    return 'readComprehensionFile';
   }
 
   /**
@@ -1026,9 +1225,9 @@ class ToothFairyAPI {
     filePath,
     userId,
     title = null,
-    folderId = "mrcRoot",
+    folderId = 'mrcRoot',
     topics = [],
-    status = "published",
+    status = 'published',
     scope = null
   ) {
     try {
@@ -1038,7 +1237,7 @@ class ToothFairyAPI {
       // Use filename as title if not provided
       let documentTitle = title;
       if (!documentTitle) {
-        if (filePath.startsWith("http://") || filePath.startsWith("https://")) {
+        if (filePath.startsWith('http://') || filePath.startsWith('https://')) {
           documentTitle = filePath;
         } else {
           documentTitle = path.basename(filePath);
@@ -1047,7 +1246,7 @@ class ToothFairyAPI {
 
       // Determine external path based on file type
       let externalPath;
-      if (type === "readComprehensionUrl") {
+      if (type === 'readComprehensionUrl') {
         externalPath = filePath; // Use URL directly
       } else {
         // For files, construct S3 path
@@ -1065,14 +1264,14 @@ class ToothFairyAPI {
             topics: topics,
             folderid: folderId,
             external_path: externalPath,
-            source: "api",
+            source: 'api',
             status: status,
             ...(scope && { scope: scope }),
           },
         ],
       };
 
-      return await this._makeRequest("POST", "doc/create", documentData);
+      return await this._makeRequest('POST', 'doc/create', documentData);
     } catch (error) {
       console.error(`Error creating document: ${error.message}`);
       throw error;
@@ -1103,7 +1302,7 @@ class ToothFairyAPI {
         },
       };
 
-      return await this._makeRequest("POST", "doc/update", updateData);
+      return await this._makeRequest('POST', 'doc/update', updateData);
     } catch (error) {
       console.error(`Error updating document: ${error.message}`);
       throw error;
@@ -1118,7 +1317,7 @@ class ToothFairyAPI {
    */
   async deleteDocument(documentId) {
     try {
-      return await this._makeRequest("DELETE", `doc/delete/${documentId}`);
+      return await this._makeRequest('DELETE', `doc/delete/${documentId}`);
     } catch (error) {
       console.error(`Error deleting document: ${error.message}`);
       throw error;
@@ -1133,7 +1332,7 @@ class ToothFairyAPI {
    */
   async getDocument(documentId) {
     try {
-      return await this._makeRequest("GET", `doc/get/${documentId}`);
+      return await this._makeRequest('GET', `doc/get/${documentId}`);
     } catch (error) {
       console.error(`Error getting document: ${error.message}`);
       throw error;
@@ -1155,7 +1354,7 @@ class ToothFairyAPI {
   async createEntity(
     userId,
     label,
-    type = "topic",
+    type = 'topic',
     description = null,
     emoji = null,
     parentEntity = null,
@@ -1173,7 +1372,7 @@ class ToothFairyAPI {
         ...(backgroundColor && { backgroundColor: backgroundColor }),
       };
 
-      return await this._makeRequest("POST", "entity/create", entityData);
+      return await this._makeRequest('POST', 'entity/create', entityData);
     } catch (error) {
       console.error(`Error creating entity: ${error.message}`);
       throw error;
@@ -1200,7 +1399,7 @@ class ToothFairyAPI {
         ...fields,
       };
 
-      return await this._makeRequest("POST", "entity/update", updateData);
+      return await this._makeRequest('POST', 'entity/update', updateData);
     } catch (error) {
       console.error(`Error updating entity: ${error.message}`);
       throw error;
@@ -1215,7 +1414,7 @@ class ToothFairyAPI {
    */
   async deleteEntity(entityId) {
     try {
-      return await this._makeRequest("DELETE", `entity/delete/${entityId}`);
+      return await this._makeRequest('DELETE', `entity/delete/${entityId}`);
     } catch (error) {
       console.error(`Error deleting entity: ${error.message}`);
       throw error;
@@ -1230,7 +1429,7 @@ class ToothFairyAPI {
    */
   async getEntity(entityId) {
     try {
-      return await this._makeRequest("GET", `entity/get/${entityId}`);
+      return await this._makeRequest('GET', `entity/get/${entityId}`);
     } catch (error) {
       console.error(`Error getting entity: ${error.message}`);
       throw error;
@@ -1249,7 +1448,7 @@ class ToothFairyAPI {
       if (limit) {
         params.limit = limit;
       }
-      return await this._makeRequest("GET", "entity/list", params);
+      return await this._makeRequest('GET', 'entity/list', params);
     } catch (error) {
       console.error(`Error listing entities: ${error.message}`);
       throw error;
@@ -1287,7 +1486,7 @@ class ToothFairyAPI {
         ...(status && { status: status }),
         ...(parent && { parent: parent }),
       };
-      return await this._makeRequest("POST", "folder/create", folderData);
+      return await this._makeRequest('POST', 'folder/create', folderData);
     } catch (error) {
       console.error(`Error creating folder: ${error.message}`);
       throw error;
@@ -1322,7 +1521,7 @@ class ToothFairyAPI {
         ...(status && { status: status }),
         ...(parent !== null && { parent: parent }),
       };
-      return await this._makeRequest("POST", "folder/update", updateData);
+      return await this._makeRequest('POST', 'folder/update', updateData);
     } catch (error) {
       console.error(`Error updating folder: ${error.message}`);
       throw error;
@@ -1337,7 +1536,7 @@ class ToothFairyAPI {
    */
   async deleteFolder(folderId) {
     try {
-      return await this._makeRequest("DELETE", `folder/delete/${folderId}`);
+      return await this._makeRequest('DELETE', `folder/delete/${folderId}`);
     } catch (error) {
       console.error(`Error deleting folder: ${error.message}`);
       throw error;
@@ -1352,7 +1551,7 @@ class ToothFairyAPI {
    */
   async getFolder(folderId) {
     try {
-      return await this._makeRequest("GET", `folder/get/${folderId}`);
+      return await this._makeRequest('GET', `folder/get/${folderId}`);
     } catch (error) {
       console.error(`Error getting folder: ${error.message}`);
       throw error;
@@ -1379,7 +1578,7 @@ class ToothFairyAPI {
       if (offset) {
         params.offset = offset;
       }
-      return await this._makeRequest("GET", "folder/list", params);
+      return await this._makeRequest('GET', 'folder/list', params);
     } catch (error) {
       console.error(`Error listing folders: ${error.message}`);
       throw error;
@@ -1429,7 +1628,7 @@ class ToothFairyAPI {
         ...(promptPlaceholder && { promptPlaceholder: promptPlaceholder }),
         ...(availableToAgents && { availableToAgents: availableToAgents }),
       };
-      return await this._makeRequest("POST", "prompt/create", promptData);
+      return await this._makeRequest('POST', 'prompt/create', promptData);
     } catch (error) {
       console.error(`Error creating prompt: ${error.message}`);
       throw error;
@@ -1482,7 +1681,7 @@ class ToothFairyAPI {
           availableToAgents: availableToAgents,
         }),
       };
-      return await this._makeRequest("POST", "prompt/update", updateData);
+      return await this._makeRequest('POST', 'prompt/update', updateData);
     } catch (error) {
       console.error(`Error updating prompt: ${error.message}`);
       throw error;
@@ -1497,7 +1696,7 @@ class ToothFairyAPI {
    */
   async deletePrompt(promptId) {
     try {
-      return await this._makeRequest("DELETE", `prompt/delete/${promptId}`);
+      return await this._makeRequest('DELETE', `prompt/delete/${promptId}`);
     } catch (error) {
       console.error(`Error deleting prompt: ${error.message}`);
       throw error;
@@ -1512,7 +1711,7 @@ class ToothFairyAPI {
    */
   async getPrompt(promptId) {
     try {
-      return await this._makeRequest("GET", `prompt/get/${promptId}`);
+      return await this._makeRequest('GET', `prompt/get/${promptId}`);
     } catch (error) {
       console.error(`Error getting prompt: ${error.message}`);
       throw error;
@@ -1539,7 +1738,7 @@ class ToothFairyAPI {
       if (offset) {
         params.offset = offset;
       }
-      return await this._makeRequest("GET", "prompt/list", params);
+      return await this._makeRequest('GET', 'prompt/list', params);
     } catch (error) {
       console.error(`Error listing prompts: ${error.message}`);
       throw error;
@@ -1564,18 +1763,18 @@ class ToothFairyAPI {
       };
 
       const config = {
-        method: "POST",
+        method: 'POST',
         url: `${this.baseUrl}/media/audio_generation`,
         headers: {
-          "Content-Type": "application/json",
-          "x-api-key": this.headers["x-api-key"],
+          'Content-Type': 'application/json',
+          'x-api-key': this.headers['x-api-key'],
         },
         data: speechData,
       };
 
       if (this.verbose) {
-        const chalk = require("chalk");
-        console.error(chalk.dim("\n--- Speech Generation Request Debug ---"));
+        const chalk = require('chalk');
+        console.error(chalk.dim('\n--- Speech Generation Request Debug ---'));
         console.error(chalk.dim(`Method: ${config.method}`));
         console.error(chalk.dim(`URL: ${config.url}`));
         console.error(
@@ -1584,28 +1783,28 @@ class ToothFairyAPI {
         console.error(
           chalk.dim(`Data: ${JSON.stringify(config.data, null, 2)}`)
         );
-        console.error(chalk.dim("--------------------------------------\n"));
+        console.error(chalk.dim('--------------------------------------\n'));
       }
 
       const response = await axios(config);
 
       if (this.verbose) {
-        const chalk = require("chalk");
-        console.error(chalk.dim("\n--- Speech Generation Response Debug ---"));
+        const chalk = require('chalk');
+        console.error(chalk.dim('\n--- Speech Generation Response Debug ---'));
         console.error(
           chalk.dim(`Status: ${response.status} ${response.statusText}`)
         );
         console.error(
           chalk.dim(`Response Data: ${JSON.stringify(response.data, null, 2)}`)
         );
-        console.error(chalk.dim("---------------------------------------\n"));
+        console.error(chalk.dim('---------------------------------------\n'));
       }
 
       return response.data;
     } catch (error) {
       if (this.verbose) {
-        const chalk = require("chalk");
-        console.error(chalk.red("\n--- Speech Generation Error Debug ---"));
+        const chalk = require('chalk');
+        console.error(chalk.red('\n--- Speech Generation Error Debug ---'));
         console.error(chalk.red(`Error: ${error.message}`));
         if (error.response) {
           console.error(
@@ -1619,7 +1818,7 @@ class ToothFairyAPI {
             )
           );
         }
-        console.error(chalk.red("------------------------------------\n"));
+        console.error(chalk.red('------------------------------------\n'));
       }
       console.error(`Error generating speech: ${error.message}`);
       throw error;
@@ -1642,18 +1841,18 @@ class ToothFairyAPI {
       };
 
       const config = {
-        method: "POST",
+        method: 'POST',
         url: `${this.baseUrl}/media/audio`,
         headers: {
-          "Content-Type": "application/json",
-          "x-api-key": this.headers["x-api-key"],
+          'Content-Type': 'application/json',
+          'x-api-key': this.headers['x-api-key'],
         },
         data: audioData,
       };
 
       if (this.verbose) {
-        const chalk = require("chalk");
-        console.error(chalk.dim("\n--- Audio Processing Request Debug ---"));
+        const chalk = require('chalk');
+        console.error(chalk.dim('\n--- Audio Processing Request Debug ---'));
         console.error(chalk.dim(`Method: ${config.method}`));
         console.error(chalk.dim(`URL: ${config.url}`));
         console.error(
@@ -1662,28 +1861,28 @@ class ToothFairyAPI {
         console.error(
           chalk.dim(`Data: ${JSON.stringify(config.data, null, 2)}`)
         );
-        console.error(chalk.dim("------------------------------------\n"));
+        console.error(chalk.dim('------------------------------------\n'));
       }
 
       const response = await axios(config);
 
       if (this.verbose) {
-        const chalk = require("chalk");
-        console.error(chalk.dim("\n--- Audio Processing Response Debug ---"));
+        const chalk = require('chalk');
+        console.error(chalk.dim('\n--- Audio Processing Response Debug ---'));
         console.error(
           chalk.dim(`Status: ${response.status} ${response.statusText}`)
         );
         console.error(
           chalk.dim(`Response Data: ${JSON.stringify(response.data, null, 2)}`)
         );
-        console.error(chalk.dim("-------------------------------------\n"));
+        console.error(chalk.dim('-------------------------------------\n'));
       }
 
       return response.data;
     } catch (error) {
       if (this.verbose) {
-        const chalk = require("chalk");
-        console.error(chalk.red("\n--- Audio Processing Error Debug ---"));
+        const chalk = require('chalk');
+        console.error(chalk.red('\n--- Audio Processing Error Debug ---'));
         console.error(chalk.red(`Error: ${error.message}`));
         if (error.response) {
           console.error(
@@ -1697,7 +1896,7 @@ class ToothFairyAPI {
             )
           );
         }
-        console.error(chalk.red("----------------------------------\n"));
+        console.error(chalk.red('----------------------------------\n'));
       }
       console.error(`Error processing audio: ${error.message}`);
       throw error;
@@ -1724,16 +1923,16 @@ class ToothFairyAPI {
     try {
       // Validate attachment limits
       if (attachments.images && attachments.images.length > 1) {
-        throw new Error("Maximum 1 image attachment allowed");
+        throw new Error('Maximum 1 image attachment allowed');
       }
       if (attachments.audios && attachments.audios.length > 1) {
-        throw new Error("Maximum 1 audio attachment allowed");
+        throw new Error('Maximum 1 audio attachment allowed');
       }
       if (attachments.videos && attachments.videos.length > 1) {
-        throw new Error("Maximum 1 video attachment allowed");
+        throw new Error('Maximum 1 video attachment allowed');
       }
       if (attachments.files && attachments.files.length > 5) {
-        throw new Error("Maximum 5 file attachments allowed");
+        throw new Error('Maximum 5 file attachments allowed');
       }
 
       // Process images
@@ -1789,10 +1988,10 @@ class ToothFairyAPI {
       }
 
       if (this.verbose) {
-        const chalk = require("chalk");
-        console.error(chalk.dim("\n--- Processed Attachments ---"));
+        const chalk = require('chalk');
+        console.error(chalk.dim('\n--- Processed Attachments ---'));
         console.error(chalk.dim(`Result: ${JSON.stringify(result, null, 2)}`));
-        console.error(chalk.dim("-----------------------------\n"));
+        console.error(chalk.dim('-----------------------------\n'));
       }
 
       return result;