nodejs-insta-private-api-mqtt 1.3.14 → 1.3.16

package/dist/realtime/commands/enhanced.direct.commands.js

@@ -14,6 +14,57 @@ class EnhancedDirectCommands {
         this.enhancedDebug = (0, shared_1.debugChannel)('realtime', 'enhanced-commands');
     }
 
+    // ---------- HELPERS ----------
+    async _publishMqttCommand(commandObj) {
+        // helper: compress + publish to SEND_MESSAGE topic
+        const mqtt = this.realtimeClient.mqtt || this.realtimeClient._mqtt;
+        if (!mqtt || typeof mqtt.publish !== 'function') {
+            throw new Error('MQTT client not available');
+        }
+        const json = JSON.stringify(commandObj);
+        const { compressDeflate } = shared_1;
+        const payload = await compressDeflate(json);
+        this.enhancedDebug(`Publishing to MQTT topic ${constants_1.Topics.SEND_MESSAGE.id} payload=${json}`);
+        const result = await mqtt.publish({
+            topic: constants_1.Topics.SEND_MESSAGE.id,
+            qosLevel: 1,
+            payload: payload,
+        });
+        return result;
+    }
+
+    /**
+     * Publish a media reference via MQTT (send_item with upload_id)
+     * This tells the server: "I have upload_id X, attach it to thread Y"
+     */
+    async sendMediaViaMqtt({ threadId, uploadId, clientContext, text, mediaId }) {
+        this.enhancedDebug(`sendMediaViaMqtt: thread=${threadId} upload_id=${uploadId}`);
+        if (!threadId) throw new Error('threadId is required');
+        if (!uploadId) throw new Error('uploadId is required');
+
+        const ctx = clientContext || (0, uuid_1.v4)();
+        const command = {
+            action: 'send_item',
+            thread_id: threadId,
+            item_type: 'media',
+            upload_id: String(uploadId),
+            client_context: ctx,
+            timestamp: Date.now(),
+        };
+        // optional fields if present
+        if (typeof text === 'string' && text.length > 0) {
+            // Instagram sometimes keeps a caption in the media message; include as text
+            command.text = text;
+        }
+        if (mediaId) {
+            // sometimes media_id is sent along, include if present
+            command.media_id = mediaId;
+        }
+
+        return this._publishMqttCommand(command);
+    }
+
+    // ---------- TEXT / BASIC COMMANDS (unchanged behavior) ----------
     /**
      * Send text via MQTT with proper payload format
      */
@@ -502,47 +553,108 @@ class EnhancedDirectCommands {
     }
 
     /**
-     * Send media (image/video) via MQTT
+     * Send media (image/video)
+     *
+     * Behavior: 
+     *  - if mediaBuffer provided -> perform rupload (REST) to get upload_id, then send MQTT send_item with upload_id (no REST broadcast)
+     *  - if only uploadId provided -> send MQTT send_item with upload_id
      */
-    async sendMedia({ text, mediaId, threadId, clientContext, uploadId }) {
-        this.enhancedDebug(`Sending media ${mediaId} (uploadId: ${uploadId}) to ${threadId} via MQTT`);
-        
+    async sendMedia({ text, mediaId, threadId, clientContext, uploadId, mediaBuffer, mimeType = 'image/jpeg', duration = 0, width = 720, height = 1280 }) {
+        this.enhancedDebug(`sendMedia called for thread ${threadId} (will rupload if buffer provided)`);
         try {
-            const mqtt = this.realtimeClient.mqtt || this.realtimeClient._mqtt;
-            if (!mqtt || typeof mqtt.publish !== 'function') {
-                throw new Error('MQTT client not available');
+            if (!threadId) {
+                throw new Error('threadId is required');
             }
-            
-            const ctx = clientContext || (0, uuid_1.v4)();
-            const command = {
-                action: 'send_item',
-                thread_id: threadId,
-                item_type: 'media',
-                media_id: mediaId,
-                upload_id: uploadId || mediaId,
-                text: text || '',
-                timestamp: Date.now(),
-                client_context: ctx,
-            };
-            
-            // Log payload for debugging
-            this.enhancedDebug(`Payload: ${JSON.stringify(command)}`);
-            
-            const json = JSON.stringify(command);
-            const { compressDeflate } = shared_1;
-            const payload = await compressDeflate(json);
-            
-            this.enhancedDebug(`Publishing media to MQTT topic ${constants_1.Topics.SEND_MESSAGE.id}`);
-            const result = await mqtt.publish({
-                topic: constants_1.Topics.SEND_MESSAGE.id,
-                qosLevel: 1,
-                payload: payload,
+
+            const ig = this.realtimeClient.ig;
+            if (!ig || !ig.request) {
+                throw new Error('Instagram client not available. Make sure you are logged in.');
+            }
+
+            let serverUploadId = uploadId || null;
+            const isVideo = mimeType && mimeType.startsWith('video/');
+
+            if (mediaBuffer) {
+                if (!Buffer.isBuffer(mediaBuffer) || mediaBuffer.length === 0) {
+                    throw new Error('mediaBuffer must be a non-empty Buffer when provided');
+                }
+
+                // generate upload id and object name
+                serverUploadId = serverUploadId || Date.now().toString();
+                const objectName = `${(0, uuid_1.v4)()}.${isVideo ? 'mp4' : (mimeType === 'image/png' ? 'png' : 'jpg')}`;
+
+                const ruploadParams = isVideo
+                    ? {
+                          upload_id: serverUploadId,
+                          media_type: 2,
+                          xsharing_user_ids: JSON.stringify([]),
+                          upload_media_duration_ms: Math.round(duration * 1000),
+                          upload_media_width: width,
+                          upload_media_height: height,
+                      }
+                    : {
+                          upload_id: serverUploadId,
+                          media_type: 1,
+                          image_compression: '{"lib_name":"moz","lib_version":"3.1.m","quality":"80"}',
+                          xsharing_user_ids: JSON.stringify([]),
+                          is_clips_media: false,
+                      };
+
+                const uploadHeaders = {
+                    'X-Instagram-Rupload-Params': JSON.stringify(ruploadParams),
+                    'Content-Type': mimeType,
+                    'X-Entity-Type': mimeType,
+                    'X-Entity-Length': String(mediaBuffer.length),
+                    'Content-Length': String(mediaBuffer.length),
+                };
+
+                if (isVideo) {
+                    uploadHeaders['X_FB_VIDEO_WATERFALL_ID'] = (0, uuid_1.v4)();
+                    uploadHeaders['Offset'] = '0';
+                } else {
+                    uploadHeaders['X_FB_PHOTO_WATERFALL_ID'] = (0, uuid_1.v4)();
+                }
+
+                const uploadUrl = isVideo ? `/rupload_igvideo/${objectName}` : `/rupload_igphoto/${objectName}`;
+
+                this.enhancedDebug(`Uploading media to ${uploadUrl} (${mediaBuffer.length} bytes)`);
+                try {
+                    const uploadResponse = await ig.request.send({
+                        url: uploadUrl,
+                        method: 'POST',
+                        headers: uploadHeaders,
+                        body: mediaBuffer,
+                    });
+
+                    if (uploadResponse && typeof uploadResponse === 'object' && uploadResponse.upload_id) {
+                        serverUploadId = uploadResponse.upload_id;
+                    }
+                    this.enhancedDebug(`✅ Media uploaded (serverUploadId=${serverUploadId})`);
+                } catch (uploadErr) {
+                    this.enhancedDebug(`Upload error: ${uploadErr.message}`);
+                    throw new Error(`Media upload failed: ${uploadErr.message}`);
+                }
+            }
+
+            // now we must have upload id
+            if (!serverUploadId) {
+                throw new Error('uploadId is required if mediaBuffer is not provided');
+            }
+
+            // Publish MQTT reference (no REST broadcast)
+            const publishResult = await this.sendMediaViaMqtt({
+                threadId,
+                uploadId: serverUploadId,
+                clientContext,
+                text,
+                mediaId,
             });
-            
-            this.enhancedDebug(`✅ Media sent via MQTT!`);
-            return result;
+
+            this.enhancedDebug(`✅ Media reference published via MQTT for upload_id=${serverUploadId}`);
+            return publishResult;
+
         } catch (err) {
-            this.enhancedDebug(`Media send failed: ${err.message}`);
+            this.enhancedDebug(`sendMedia failed: ${err.message}`);
             throw err;
         }
     }
@@ -756,18 +868,11 @@ class EnhancedDirectCommands {
     }
 
     /**
-     * Send photo via Realtime (Upload + Broadcast)
-     * This method uploads the photo first, then broadcasts it to the thread
-     * 
-     * @param {Object} options - Photo sending options
-     * @param {Buffer} options.photoBuffer - Image buffer (JPEG/PNG)
-     * @param {string} options.threadId - Thread ID to send to
-     * @param {string} [options.caption] - Optional caption
-     * @param {string} [options.mimeType='image/jpeg'] - MIME type
-     * @param {string} [options.clientContext] - Optional client context
+     * Send photo via Realtime (Upload + MQTT-ref)
+     * Uploads the photo via rupload, then sends MQTT send_item with upload_id.
      */
     async sendPhotoViaRealtime({ photoBuffer, threadId, caption = '', mimeType = 'image/jpeg', clientContext }) {
-        this.enhancedDebug(`Sending photo to thread ${threadId} via Realtime`);
+        this.enhancedDebug(`Sending photo to thread ${threadId} via Realtime (rupload + mqtt-ref)`);
         
         try {
             // Validate inputs
@@ -778,87 +883,15 @@ class EnhancedDirectCommands {
                 throw new Error('threadId is required');
             }
 
-            // Get the ig client from realtime client
-            const ig = this.realtimeClient.ig;
-            if (!ig || !ig.request) {
-                throw new Error('Instagram client not available. Make sure you are logged in.');
-            }
-
-            // Step 1: Upload photo using rupload endpoint
-            this.enhancedDebug(`Step 1: Uploading photo (${photoBuffer.length} bytes)...`);
-            
-            const uploadId = Date.now().toString();
-            const objectName = `${(0, uuid_1.v4)()}.${mimeType === 'image/png' ? 'png' : 'jpg'}`;
-            
-            const isJpeg = mimeType === 'image/jpeg' || mimeType === 'image/jpg';
-            const compression = isJpeg
-                ? '{"lib_name":"moz","lib_version":"3.1.m","quality":"80"}'
-                : '{"lib_name":"png","lib_version":"1.0","quality":"100"}';
-
-            const ruploadParams = {
-                upload_id: uploadId,
-                media_type: 1,
-                image_compression: compression,
-                xsharing_user_ids: JSON.stringify([]),
-                is_clips_media: false,
-            };
-
-            const uploadHeaders = {
-                'X-Instagram-Rupload-Params': JSON.stringify(ruploadParams),
-                'Content-Type': mimeType,
-                'X_FB_PHOTO_WATERFALL_ID': (0, uuid_1.v4)(),
-                'X-Entity-Type': mimeType,
-                'X-Entity-Length': String(photoBuffer.length),
-                'Content-Length': String(photoBuffer.length),
-            };
-
-            const uploadUrl = `/rupload_igphoto/${objectName}`;
-
-            let serverUploadId = uploadId;
-            try {
-                const uploadResponse = await ig.request.send({
-                    url: uploadUrl,
-                    method: 'POST',
-                    headers: uploadHeaders,
-                    body: photoBuffer,
-                });
-
-                if (uploadResponse && typeof uploadResponse === 'object' && uploadResponse.upload_id) {
-                    serverUploadId = uploadResponse.upload_id;
-                }
-                this.enhancedDebug(`✅ Photo uploaded! upload_id: ${serverUploadId}`);
-            } catch (uploadErr) {
-                this.enhancedDebug(`Upload error: ${uploadErr.message}`);
-                throw new Error(`Photo upload failed: ${uploadErr.message}`);
-            }
-
-            // Step 2: Broadcast the uploaded photo to the thread
-            this.enhancedDebug(`Step 2: Broadcasting photo to thread ${threadId}...`);
-            
-            const broadcastForm = {
-                upload_id: serverUploadId,
-                action: 'send_item',
-                thread_ids: JSON.stringify([String(threadId)]),
-            };
-
-            if (caption) {
-                broadcastForm.caption = caption;
-            }
-
-            try {
-                const broadcastResponse = await ig.request.send({
-                    url: '/direct_v2/threads/broadcast/upload_photo/',
-                    method: 'POST',
-                    form: broadcastForm,
-                });
-
-                this.enhancedDebug(`✅ Photo sent successfully to thread ${threadId}!`);
-                return broadcastResponse;
-            } catch (broadcastErr) {
-                this.enhancedDebug(`Broadcast error: ${broadcastErr.message}`);
-                throw new Error(`Photo broadcast failed: ${broadcastErr.message}`);
-            }
-
+            // delegate to sendMedia which handles rupload + mqtt publish
+            const result = await this.sendMedia({
+                text: caption,
+                threadId,
+                clientContext,
+                mediaBuffer: photoBuffer,
+                mimeType,
+            });
+            return result;
         } catch (err) {
             this.enhancedDebug(`sendPhotoViaRealtime failed: ${err.message}`);
             throw err;
@@ -873,19 +906,11 @@ class EnhancedDirectCommands {
     }
 
     /**
-     * Send video via Realtime (Upload + Broadcast)
-     * 
-     * @param {Object} options - Video sending options
-     * @param {Buffer} options.videoBuffer - Video buffer (MP4)
-     * @param {string} options.threadId - Thread ID to send to
-     * @param {string} [options.caption] - Optional caption
-     * @param {number} [options.duration] - Video duration in seconds
-     * @param {number} [options.width] - Video width
-     * @param {number} [options.height] - Video height
-     * @param {string} [options.clientContext] - Optional client context
+     * Send video via Realtime (Upload + MQTT-ref)
+     * Uploads video via rupload, then sends MQTT send_item with upload_id.
      */
-    async sendVideoViaRealtime({ videoBuffer, threadId, caption = '', duration = 0, width = 720, height = 1280, clientContext }) {
-        this.enhancedDebug(`Sending video to thread ${threadId} via Realtime`);
+    async sendVideoViaRealtime({ videoBuffer, threadId, caption = '', duration = 0, width = 720, height = 1280, mimeType = 'video/mp4', clientContext }) {
+        this.enhancedDebug(`Sending video to thread ${threadId} via Realtime (rupload + mqtt-ref)`);
         
         try {
             // Validate inputs
@@ -896,85 +921,17 @@ class EnhancedDirectCommands {
                 throw new Error('threadId is required');
             }
 
-            // Get the ig client from realtime client
-            const ig = this.realtimeClient.ig;
-            if (!ig || !ig.request) {
-                throw new Error('Instagram client not available. Make sure you are logged in.');
-            }
-
-            // Step 1: Upload video using rupload endpoint
-            this.enhancedDebug(`Step 1: Uploading video (${videoBuffer.length} bytes)...`);
-            
-            const uploadId = Date.now().toString();
-            const objectName = `${(0, uuid_1.v4)()}.mp4`;
-            
-            const ruploadParams = {
-                upload_id: uploadId,
-                media_type: 2, // 2 = video
-                xsharing_user_ids: JSON.stringify([]),
-                upload_media_duration_ms: Math.round(duration * 1000),
-                upload_media_width: width,
-                upload_media_height: height,
-            };
-
-            const uploadHeaders = {
-                'X-Instagram-Rupload-Params': JSON.stringify(ruploadParams),
-                'Content-Type': 'video/mp4',
-                'X_FB_VIDEO_WATERFALL_ID': (0, uuid_1.v4)(),
-                'X-Entity-Type': 'video/mp4',
-                'X-Entity-Length': String(videoBuffer.length),
-                'Content-Length': String(videoBuffer.length),
-                'Offset': '0',
-            };
-
-            const uploadUrl = `/rupload_igvideo/${objectName}`;
-
-            let serverUploadId = uploadId;
-            try {
-                const uploadResponse = await ig.request.send({
-                    url: uploadUrl,
-                    method: 'POST',
-                    headers: uploadHeaders,
-                    body: videoBuffer,
-                });
-
-                if (uploadResponse && typeof uploadResponse === 'object' && uploadResponse.upload_id) {
-                    serverUploadId = uploadResponse.upload_id;
-                }
-                this.enhancedDebug(`✅ Video uploaded! upload_id: ${serverUploadId}`);
-            } catch (uploadErr) {
-                this.enhancedDebug(`Video upload error: ${uploadErr.message}`);
-                throw new Error(`Video upload failed: ${uploadErr.message}`);
-            }
-
-            // Step 2: Broadcast the uploaded video to the thread
-            this.enhancedDebug(`Step 2: Broadcasting video to thread ${threadId}...`);
-            
-            const broadcastForm = {
-                upload_id: serverUploadId,
-                action: 'send_item',
-                thread_ids: JSON.stringify([String(threadId)]),
-                video_result: '',
-            };
-
-            if (caption) {
-                broadcastForm.caption = caption;
-            }
-
-            try {
-                const broadcastResponse = await ig.request.send({
-                    url: '/direct_v2/threads/broadcast/upload_video/',
-                    method: 'POST',
-                    form: broadcastForm,
-                });
-
-                this.enhancedDebug(`✅ Video sent successfully to thread ${threadId}!`);
-                return broadcastResponse;
-            } catch (broadcastErr) {
-                this.enhancedDebug(`Video broadcast error: ${broadcastErr.message}`);
-                throw new Error(`Video broadcast failed: ${broadcastErr.message}`);
-            }
-
+            const result = await this.sendMedia({
+                text: caption,
+                threadId,
+                clientContext,
+                mediaBuffer: videoBuffer,
+                mimeType,
+                duration,
+                width,
+                height,
+            });
+            return result;
         } catch (err) {
             this.enhancedDebug(`sendVideoViaRealtime failed: ${err.message}`);
             throw err;

package/dist/repositories/direct-thread.repository.js

@@ -20,12 +20,15 @@ class DirectThreadRepository extends Repository {
     } catch (error) {
       const shouldRetry =
         (error.data?.error_type === 'server_error' ||
-         error.data?.error_type === 'rate_limited') &&
+         error.data?.error_type === 'rate_limited' ||
+         error.name === 'IgActionSpamError' ||
+         error.status === 503 ||
+         error.status === 429) &&
         retries < this.maxRetries;
 
       if (shouldRetry) {
         const delay = 1000 * (retries + 1);
-        if (process.env.DEBUG) console.log(`[DEBUG] Retrying after ${delay}ms due to ${error.data?.error_type}`);
+        if (process.env.DEBUG) console.log(`[DEBUG] Retrying after ${delay}ms due to ${error.data?.error_type || error.message || error.name || error.status}`);
         await new Promise(resolve => setTimeout(resolve, delay));
         return this.requestWithRetry(requestFn, retries + 1);
       }
@@ -59,7 +62,7 @@ class DirectThreadRepository extends Repository {
         method: 'GET',
         url: `/api/v1/direct_v2/threads/${threadId}/`,
       });
-      return response.body;
+      return response.body || response.data || response;
     });
   }
 
@@ -74,7 +77,7 @@ class DirectThreadRepository extends Repository {
         url: '/api/v1/direct_v2/threads/get_by_participants/',
         qs: { recipient_users: JSON.stringify(recipientUsers) },
       });
-      return response.body;
+      return response.body || response.data || response;
     });
   }
 
@@ -99,13 +102,102 @@ class DirectThreadRepository extends Repository {
     };
 
     return this.requestWithRetry(async () => {
+      const payloadForm = options.signed && this.client.request && typeof this.client.request.sign === 'function'
+        ? this.client.request.sign(form)
+        : form;
+
       const response = await this.client.request.send({
         url: `/api/v1/direct_v2/threads/broadcast/${options.item}/`,
         method: 'POST',
-        form: options.signed ? this.client.request.sign(form) : form,
+        form: payloadForm,
         qs: options.qs,
       });
-      return response.body;
+      return response.body || response.data || response;
+    });
+  }
+
+  /**
+   * Broadcast a photo to one or more threads (uses REST configure_photo)
+   * Options:
+   *  - uploadId (required) : upload_id returned from rupload
+   *  - threadIds or threadId (required) : target thread id(s)
+   *  - caption (optional) : caption/text to attach
+   *  - signed (optional, default true) : whether to sign the form (if client.request.sign available)
+   */
+  async broadcastPhoto(options) {
+    // normalize inputs
+    const uploadId = options.uploadId || options.upload_id || options.uploadIdStr;
+    const threadIds = options.threadIds || (options.threadId ? [options.threadId] : []);
+    const caption = options.caption || options.text || '';
+    const signed = (options.signed === undefined) ? true : !!options.signed; // default to true for media
+    const mutationToken = new Chance().guid();
+    const clientContext = mutationToken;
+
+    if (!uploadId) throw new Error('broadcastPhoto: uploadId is required');
+    if (!threadIds || !Array.isArray(threadIds) || threadIds.length === 0) throw new Error('broadcastPhoto: at least one threadId is required');
+
+    // Build the form closely matching instagram-private-api / official client expectations
+    const form = {
+      action: 'send_item', // must be send_item for DM photo
+      upload_id: uploadId.toString(),
+      thread_ids: JSON.stringify(threadIds),
+      client_context: clientContext,
+      mutation_token: mutationToken,
+      offline_threading_id: clientContext,
+      _csrftoken: this.client.state.cookieCsrfToken,
+      device_id: this.client.state.deviceId,
+      _uuid: this.client.state.uuid,
+    };
+
+    if (caption) {
+      // Instagram often expects 'text' for the message body
+      form.text = caption;
+    }
+
+    // perform request with retry wrapper
+    return this.requestWithRetry(async () => {
+      const payloadForm = (signed && this.client.request && typeof this.client.request.sign === 'function')
+        ? this.client.request.sign(form)
+        : form;
+
+      const response = await this.client.request.send({
+        url: `/api/v1/direct_v2/threads/broadcast/configure_photo/`,
+        method: 'POST',
+        form: payloadForm,
+        qs: {
+          use_unified_inbox: true,
+        },
+      });
+
+      // normalize: some wrappers return { body } or axios response
+      const body = response && (response.body || response.data || response);
+
+      if (!body) {
+        const err = new Error('broadcastPhoto: empty response');
+        throw err;
+      }
+
+      // parse if string
+      let parsed = null;
+      if (typeof body === 'string') {
+        try {
+          parsed = JSON.parse(body);
+        } catch (e) {
+          parsed = null;
+        }
+      } else if (typeof body === 'object') {
+        parsed = body;
+      }
+
+      // Typical success: parsed.status === 'ok' OR parsed.media/parsed.result/payload present
+      const ok = parsed && (parsed.status === 'ok' || parsed.media || parsed.result || parsed.payload || parsed.items || parsed.thread);
+      if (ok) return parsed;
+
+      // If we reach here, treat as error to trigger retry logic
+      const error = new Error('broadcastPhoto: Request failed');
+      error.response = response;
+      if (parsed) error.data = parsed;
+      throw error;
     });
   }
 
@@ -126,7 +218,7 @@ class DirectThreadRepository extends Repository {
           item_id: threadItemId,
         },
       });
-      return response.body;
+      return response.body || response.data || response;
     });
   }
 
@@ -140,7 +232,7 @@ class DirectThreadRepository extends Repository {
         method: 'POST',
         form: { _csrftoken: this.client.state.cookieCsrfToken, _uuid: this.client.state.uuid },
       });
-      return response.body;
+      return response.body || response.data || response;
     });
   }
 
@@ -154,7 +246,7 @@ class DirectThreadRepository extends Repository {
         method: 'POST',
         form: { _csrftoken: this.client.state.cookieCsrfToken, _uuid: this.client.state.uuid },
       });
-      return response.body;
+      return response.body || response.data || response;
     });
   }
 
@@ -168,7 +260,7 @@ class DirectThreadRepository extends Repository {
         method: 'POST',
         form: { _csrftoken: this.client.state.cookieCsrfToken, _uuid: this.client.state.uuid },
       });
-      return response.body;
+      return response.body || response.data || response;
     });
   }
 
@@ -182,7 +274,7 @@ class DirectThreadRepository extends Repository {
         method: 'POST',
         form: { _csrftoken: this.client.state.cookieCsrfToken, _uuid: this.client.state.uuid },
       });
-      return response.body;
+      return response.body || response.data || response;
     });
   }
 
@@ -196,7 +288,7 @@ class DirectThreadRepository extends Repository {
         method: 'POST',
         form: { _csrftoken: this.client.state.cookieCsrfToken, _uuid: this.client.state.uuid },
       });
-      return response.body;
+      return response.body || response.data || response;
     });
   }
 
@@ -211,7 +303,7 @@ class DirectThreadRepository extends Repository {
         method: 'POST',
         form: { _csrftoken: this.client.state.cookieCsrfToken, user_ids: JSON.stringify(userIds), _uuid: this.client.state.uuid },
       });
-      return response.body;
+      return response.body || response.data || response;
     });
   }
 
@@ -225,7 +317,7 @@ class DirectThreadRepository extends Repository {
         method: 'POST',
         form: { _csrftoken: this.client.state.cookieCsrfToken, _uuid: this.client.state.uuid },
       });
-      return response.body;
+      return response.body || response.data || response;
     });
   }
 
@@ -239,9 +331,10 @@ class DirectThreadRepository extends Repository {
         method: 'POST',
         form: { _csrftoken: this.client.state.cookieCsrfToken, _uuid: this.client.state.uuid, title },
       });
-      return response.body;
+      return response.body || response.data || response;
     });
   }
 }
 
 module.exports = DirectThreadRepository;
+