gemini-reverse 1.0.2 → 1.0.3

package/index.js

@@ -1,9 +1,22 @@
 'use strict';
 
 const { GeminiClient, ChatSession } = require('./client');
-const { Model, GRPC, Endpoint, Headers, ErrorCode, TEMPORARY_CHAT_FLAG_INDEX } = require('./constants');
-const { AuthError, APIError, ImageGenerationError, GeminiError, TimeoutError, UsageLimitExceeded, ModelInvalid, TemporarilyBlocked } = require('./exceptions');
-const { Candidate, ConversationTurn, Gem, GemJar, RPCData, Image, WebImage, GeneratedImage, ModelOutput } = require('./types');
+const {
+    Model, GRPC, Endpoint, Headers, ErrorCode, AccountStatus,
+    TEMPORARY_CHAT_FLAG_INDEX, STREAMING_FLAG_INDEX, GEM_FLAG_INDEX,
+    CARD_CONTENT_RE, ARTIFACTS_RE, DEFAULT_METADATA, MODEL_HEADER_KEY,
+    buildModelHeader,
+} = require('./constants');
+const {
+    AuthError, APIError, ImageGenerationError, GeminiError, TimeoutError,
+    UsageLimitExceeded, ModelInvalid, TemporarilyBlocked,
+} = require('./exceptions');
+const {
+    Candidate, ChatHistory, ChatTurn, ChatInfo, Gem, GemJar, RPCData,
+    Image, WebImage, GeneratedImage, ModelOutput,
+    DeepResearchPlan, DeepResearchStatus, DeepResearchResult,
+    Video, GeneratedVideo, GeneratedMedia, AvailableModel,
+} = require('./types');
 
 module.exports = {
     GeminiClient,
@@ -13,7 +26,15 @@ module.exports = {
     Endpoint,
     Headers,
     ErrorCode,
+    AccountStatus,
     TEMPORARY_CHAT_FLAG_INDEX,
+    STREAMING_FLAG_INDEX,
+    GEM_FLAG_INDEX,
+    CARD_CONTENT_RE,
+    ARTIFACTS_RE,
+    DEFAULT_METADATA,
+    MODEL_HEADER_KEY,
+    buildModelHeader,
     AuthError,
     APIError,
     ImageGenerationError,
@@ -23,7 +44,9 @@ module.exports = {
     ModelInvalid,
     TemporarilyBlocked,
     Candidate,
-    ConversationTurn,
+    ChatHistory,
+    ChatTurn,
+    ChatInfo,
     Gem,
     GemJar,
     RPCData,
@@ -31,4 +54,11 @@ module.exports = {
     WebImage,
     GeneratedImage,
     ModelOutput,
-};
+    DeepResearchPlan,
+    DeepResearchStatus,
+    DeepResearchResult,
+    Video,
+    GeneratedVideo,
+    GeneratedMedia,
+    AvailableModel,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gemini-reverse",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "Unofficial Node.js client for gemini.google.com — inspired by Gemini-API (Python). Supports streaming, chat sessions, gems, file uploads, and TypeScript.",
   "main": "index.js",
   "types": "index.d.ts",

package/types/availablemodel.js

@@ -0,0 +1,76 @@
+'use strict';
+
+const { buildModelHeader, MODEL_HEADER_KEY, Model } = require('../constants');
+
+class AvailableModel {
+    constructor({ model_id, model_name, display_name, description, capacity, capacity_field = 12, is_available = true } = {}) {
+        this.model_id = model_id;
+        this.model_name = model_name;
+        this.display_name = display_name;
+        this.description = description;
+        this.capacity = capacity;
+        this.capacity_field = capacity_field;
+        this.is_available = is_available;
+    }
+
+    get model_header() {
+        let tail;
+        if (this.capacity_field === 13) {
+            tail = `null,${this.capacity}`;
+        } else {
+            tail = String(this.capacity);
+        }
+        return buildModelHeader(this.model_id, tail);
+    }
+
+    get advanced_only() {
+        return !(this.capacity === 1 && this.capacity_field === 12);
+    }
+
+    toString() {
+        return this.model_name || this.display_name;
+    }
+
+    repr() {
+        return `AvailableModel(model_id=${this.model_id}, model_name=${this.model_name}, description=${this.description})`;
+    }
+
+    static computeCapacity(tierFlags, capabilityFlags) {
+        if (tierFlags.includes(21)) return [1, 13];
+        if (tierFlags.includes(22)) return [2, 13];
+        if (capabilityFlags.includes(115)) return [4, 12];
+        if (tierFlags.includes(16) || capabilityFlags.includes(106)) return [3, 12];
+        if (tierFlags.includes(8) || (!capabilityFlags.includes(106) && capabilityFlags.includes(19))) return [2, 12];
+        return [1, 12];
+    }
+
+    static buildModelIdNameMapping() {
+        const result = {};
+        const keys = [
+            'BASIC_PRO', 'BASIC_FLASH', 'BASIC_THINKING',
+            'PLUS_PRO', 'PLUS_FLASH', 'PLUS_THINKING',
+            'ADVANCED_PRO', 'ADVANCED_FLASH', 'ADVANCED_THINKING',
+        ];
+        for (const key of keys) {
+            const member = Model[key];
+            if (!member) continue;
+            const headerValue = member.model_header[MODEL_HEADER_KEY];
+            if (!headerValue) continue;
+            try {
+                const parsed = JSON.parse(headerValue);
+                const modelId = parsed && parsed[4];
+                if (modelId && !(modelId in result)) {
+                    const baseSuffix = key.split('_').slice(1).join('_');
+                    const baseKey = 'BASIC_' + baseSuffix;
+                    const baseMember = Model[baseKey] || member;
+                    result[modelId] = baseMember.model_name;
+                }
+            } catch {
+                continue;
+            }
+        }
+        return result;
+    }
+}
+
+module.exports = { AvailableModel };

package/types/candidate.js

@@ -2,26 +2,40 @@
 
 const { WebImage, GeneratedImage } = require('./image');
 
+function decodeHtml(str) {
+    if (!str) return str;
+    return str
+        .replace(/&/g, '&')
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'")
+        .replace(/&apos;/g, "'");
+}
+
 class Candidate {
-    constructor({ rcid, text, text_delta = null, thoughts = null, thoughts_delta = null, web_images = [], generated_images = [] } = {}) {
+    constructor({
+        rcid,
+        text,
+        text_delta = null,
+        thoughts = null,
+        thoughts_delta = null,
+        web_images = [],
+        generated_images = [],
+        generated_videos = [],
+        generated_media = [],
+        deep_research_plan = null,
+    } = {}) {
         this.rcid = rcid;
-        this.text = this._decodeHtml(text);
+        this.text = decodeHtml(text);
         this.text_delta = text_delta;
-        this.thoughts = thoughts ? this._decodeHtml(thoughts) : null;
+        this.thoughts = thoughts ? decodeHtml(thoughts) : null;
         this.thoughts_delta = thoughts_delta;
         this.web_images = web_images;
         this.generated_images = generated_images;
-    }
-
-    _decodeHtml(str) {
-        if (!str) return str;
-        return str
-            .replace(/&amp;/g, '&')
-            .replace(/&lt;/g, '<')
-            .replace(/&gt;/g, '>')
-            .replace(/&quot;/g, '"')
-            .replace(/&#39;/g, '\'')
-            .replace(/&apos;/g, '\'');
+        this.generated_videos = generated_videos;
+        this.generated_media = generated_media;
+        this.deep_research_plan = deep_research_plan;
     }
 
     get images() {
@@ -31,9 +45,9 @@ class Candidate {
     toString() { return this.text; }
 
     repr() {
-        const preview = this.text.length <= 20 ? this.text : this.text.slice(0, 20) + '...';
-        return `Candidate(rcid='${this.rcid}', text='${preview}', images=${this.images.length})`;
+        const preview = this.text && this.text.length <= 100 ? this.text : (this.text ? this.text.slice(0, 100) + '...' : '');
+        return `Candidate(rcid=${this.rcid}, text=${preview}, images=${this.images.length}, videos=${this.generated_videos.length}, media=${this.generated_media.length})`;
     }
 }
 
-module.exports = { Candidate };
+module.exports = { Candidate };

package/types/chathistory.js

@@ -0,0 +1,36 @@
+'use strict';
+
+class ChatTurn {
+    constructor({ role, text, model_output = null } = {}) {
+        this.role = role;
+        this.text = text;
+        this.model_output = model_output;
+    }
+
+    toString() {
+        const preview = this.text && this.text.length > 100 ? this.text.slice(0, 100) + '...' : (this.text || '');
+        return `${this.role.toUpperCase()}: ${preview}`;
+    }
+
+    repr() {
+        const preview = this.text && this.text.length > 100 ? this.text.slice(0, 100) + '...' : (this.text || '');
+        return `ChatTurn(role=${this.role}, text=${preview})`;
+    }
+}
+
+class ChatHistory {
+    constructor({ cid, turns } = {}) {
+        this.cid = cid;
+        this.turns = turns || [];
+    }
+
+    toString() {
+        return `ChatHistory(cid=${this.cid})`;
+    }
+
+    repr() {
+        return `ChatHistory(cid=${this.cid}, turns=${JSON.stringify(this.turns)})`;
+    }
+}
+
+module.exports = { ChatTurn, ChatHistory };

package/types/chatinfo.js

@@ -0,0 +1,23 @@
+'use strict';
+
+class ChatInfo {
+    constructor({ cid, title, is_pinned = false, timestamp } = {}) {
+        this.cid = cid;
+        this.title = title;
+        this.is_pinned = is_pinned;
+        this.timestamp = timestamp;
+    }
+
+    toString() {
+        const pin = this.is_pinned ? '[Pinned] ' : '';
+        const title = this.title || `Chat(${this.cid})`;
+        const dt = new Date(this.timestamp * 1000).toISOString().replace('T', ' ').slice(0, 19);
+        return `${pin}${title} (${dt})`;
+    }
+
+    repr() {
+        return `ChatInfo(cid=${this.cid}, title=${this.title}, is_pinned=${this.is_pinned}, timestamp=${this.timestamp})`;
+    }
+}
+
+module.exports = { ChatInfo };

package/types/index.js

@@ -1,10 +1,34 @@
 'use strict';
 
 const { Candidate } = require('./candidate');
-const { ConversationTurn } = require('./conversation');
+const { ChatHistory, ChatTurn } = require('./chathistory');
+const { ChatInfo } = require('./chatinfo');
 const { Gem, GemJar } = require('./gem');
 const { RPCData } = require('./grpc');
 const { Image, WebImage, GeneratedImage } = require('./image');
 const { ModelOutput } = require('./modeloutput');
+const { DeepResearchPlan, DeepResearchStatus } = require('./research');
+const { DeepResearchResult } = require('./researchresult');
+const { Video, GeneratedVideo, GeneratedMedia } = require('./video');
+const { AvailableModel } = require('./availablemodel');
 
-module.exports = { Candidate, ConversationTurn, Gem, GemJar, RPCData, Image, WebImage, GeneratedImage, ModelOutput };
+module.exports = {
+    Candidate,
+    ChatHistory,
+    ChatTurn,
+    ChatInfo,
+    Gem,
+    GemJar,
+    RPCData,
+    Image,
+    WebImage,
+    GeneratedImage,
+    ModelOutput,
+    DeepResearchPlan,
+    DeepResearchStatus,
+    DeepResearchResult,
+    Video,
+    GeneratedVideo,
+    GeneratedMedia,
+    AvailableModel,
+};

package/types/modeloutput.js

@@ -12,6 +12,9 @@ class ModelOutput {
     get thoughts() { return this.candidates[this.chosen].thoughts; }
     get thoughts_delta() { return this.candidates[this.chosen].thoughts_delta || ''; }
     get images() { return this.candidates[this.chosen].images; }
+    get videos() { return this.candidates[this.chosen].generated_videos || []; }
+    get media() { return this.candidates[this.chosen].generated_media || []; }
+    get deep_research_plan() { return this.candidates[this.chosen].deep_research_plan || null; }
     get rcid() { return this.candidates[this.chosen].rcid; }
 
     toString() { return this.text; }
@@ -21,4 +24,4 @@ class ModelOutput {
     }
 }
 
-module.exports = { ModelOutput };
+module.exports = { ModelOutput };

package/types/research.js

@@ -0,0 +1,65 @@
+'use strict';
+
+class DeepResearchPlan {
+    constructor({
+        research_id = null,
+        title = null,
+        query = null,
+        steps = [],
+        eta_text = null,
+        confirm_prompt = null,
+        modify_prompt = null,
+        confirmation_url = null,
+        metadata = [],
+        cid = null,
+        response_text = null,
+        raw_state = null,
+    } = {}) {
+        this.research_id = research_id;
+        this.title = title;
+        this.query = query;
+        this.steps = steps;
+        this.eta_text = eta_text;
+        this.confirm_prompt = confirm_prompt;
+        this.modify_prompt = modify_prompt;
+        this.confirmation_url = confirmation_url;
+        this.metadata = metadata;
+        this.cid = cid;
+        this.response_text = response_text;
+        this.raw_state = raw_state;
+    }
+
+    repr() {
+        return `DeepResearchPlan(research_id=${this.research_id}, title=${this.title}, eta_text=${this.eta_text}, metadata=${JSON.stringify(this.metadata)})`;
+    }
+}
+
+class DeepResearchStatus {
+    constructor({
+        research_id,
+        state = 'running',
+        title = null,
+        query = null,
+        cid = null,
+        notes = [],
+        done = false,
+        raw_state = null,
+        raw = null,
+    } = {}) {
+        this.research_id = research_id;
+        this.state = state;
+        this.title = title;
+        this.query = query;
+        this.cid = cid;
+        this.notes = notes;
+        this.done = done;
+        this.raw_state = raw_state;
+        this.raw = raw;
+    }
+
+    repr() {
+        return `DeepResearchStatus(research_id=${this.research_id}, state=${this.state}, title=${this.title}, done=${this.done})`;
+    }
+}
+
+module.exports = { DeepResearchPlan, DeepResearchStatus };

package/types/researchresult.js

@@ -0,0 +1,21 @@
+'use strict';
+
+class DeepResearchResult {
+    constructor({ plan, start_output = null, final_output = null, statuses = [], done = false } = {}) {
+        this.plan = plan;
+        this.start_output = start_output;
+        this.final_output = final_output;
+        this.statuses = statuses;
+        this.done = done;
+    }
+
+    get text() {
+        return this.final_output ? this.final_output.text : '';
+    }
+
+    repr() {
+        return `DeepResearchResult(plan=${this.plan ? this.plan.repr() : null}, done=${this.done}, final_output=${this.final_output})`;
+    }
+}
+
+module.exports = { DeepResearchResult };

package/types/video.js

@@ -0,0 +1,195 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const axios = require('axios');
+const crypto = require('crypto');
+
+function sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
+
+class Video {
+    constructor({ url, title = '[Video]', proxy = null } = {}) {
+        this.url = url;
+        this.title = title;
+        this.proxy = proxy;
+        this._defaultFilenameSuffix = 'video';
+    }
+
+    _getUrlForHash() {
+        return this.url;
+    }
+
+    repr() {
+        return `Video(title=${this.title}, url=${this.url})`;
+    }
+
+    async save({ savePath = 'temp', filename = null, verbose = false } = {}) {
+        if (!filename || !path.extname(filename)) {
+            const timestamp = new Date().toISOString().replace(/[-:.TZ]/g, '').slice(0, 14);
+            const urlHash = crypto.createHash('sha256').update(this._getUrlForHash()).digest('hex').slice(0, 10);
+            const baseName = filename ? path.parse(filename).name : this._defaultFilenameSuffix;
+            filename = `${timestamp}_${urlHash}_${baseName}`;
+        }
+
+        if (!fs.existsSync(savePath)) fs.mkdirSync(savePath, { recursive: true });
+
+        return await this._performSave(savePath, filename, verbose);
+    }
+
+    async _performSave(savePath, filename, verbose) {
+        const filePath = await this._downloadFile(this.url, savePath, filename, '.mp4', verbose);
+        return { video: filePath, video_thumbnail: null };
+    }
+
+    async _downloadFile(url, savePath, filename, defaultExt = '.mp4', verbose = false) {
+        const proxyConfig = this.proxy ? this._parseProxy(this.proxy) : undefined;
+        const res = await axios.get(url, {
+            responseType: 'arraybuffer',
+            ...(proxyConfig ? { proxy: proxyConfig } : {}),
+            validateStatus: null,
+        });
+
+        if (verbose) console.debug(`HTTP Request: GET ${url} [${res.status}]`);
+
+        if (res.status === 200) {
+            let ext = defaultExt;
+            const contentType = (res.headers['content-type'] || '').split(';')[0].trim().toLowerCase();
+            if (contentType.includes('mp4')) ext = '.mp4';
+            else if (contentType.includes('mp3') || contentType.includes('mpeg')) ext = '.mp3';
+            else if (contentType.includes('jpeg')) ext = '.jpg';
+            else if (contentType.includes('png')) ext = '.png';
+            else if (contentType.includes('webm')) ext = '.webm';
+
+            if (!path.extname(filename)) filename = filename + ext;
+            const dest = path.join(savePath, filename);
+            fs.writeFileSync(dest, Buffer.from(res.data));
+            if (verbose) console.info(`File saved as ${path.resolve(dest)}`);
+            return path.resolve(dest);
+        } else if (res.status === 206) {
+            return '206';
+        } else {
+            throw new Error(`Error downloading file: ${res.status}`);
+        }
+    }
+
+    _parseProxy(proxyStr) {
+        try {
+            const u = new URL(proxyStr);
+            return { protocol: u.protocol.replace(':', ''), host: u.hostname, port: parseInt(u.port) };
+        } catch {
+            return undefined;
+        }
+    }
+}
+
+class GeneratedVideo extends Video {
+    constructor({ url, title = '[Video]', proxy = null, thumbnail = '', cid = '', rid = '', rcid = '', client_ref = null } = {}) {
+        super({ url, title, proxy });
+        this.thumbnail = thumbnail;
+        this.cid = cid;
+        this.rid = rid;
+        this.rcid = rcid;
+        this.client_ref = client_ref;
+    }
+
+    async _performSave(savePath, filename, verbose) {
+        let thumbPath = null;
+        if (this.thumbnail) {
+            const thumbBase = path.parse(filename).name;
+            try {
+                thumbPath = await this._downloadFile(this.thumbnail, savePath, thumbBase, '.jpg', verbose);
+            } catch (e) {
+                if (verbose) console.warn(`Failed to save thumbnail: ${e.message}`);
+            }
+        }
+
+        while (true) {
+            const videoPath = await this._downloadFile(this.url, savePath, filename, '.mp4', verbose);
+            if (videoPath === '206') {
+                if (verbose) console.info('Video still generating (206), retrying in 10s...');
+                await sleep(10000);
+            } else {
+                return { video: videoPath, video_thumbnail: thumbPath };
+            }
+        }
+    }
+
+    repr() {
+        return `GeneratedVideo(title=${this.title}, url=${this.url})`;
+    }
+}
+
+class GeneratedMedia extends GeneratedVideo {
+    constructor({ url, title = '[Media]', proxy = null, thumbnail = '', mp3_url = '', mp3_thumbnail = '', cid = '', rid = '', rcid = '', client_ref = null } = {}) {
+        super({ url, title, proxy, thumbnail, cid, rid, rcid, client_ref });
+        this.mp3_url = mp3_url;
+        this.mp3_thumbnail = mp3_thumbnail;
+        this._defaultFilenameSuffix = 'media';
+    }
+
+    get mp4_url() { return this.url; }
+    set mp4_url(v) { this.url = v; }
+
+    get mp4_thumbnail() { return this.thumbnail; }
+    set mp4_thumbnail(v) { this.thumbnail = v; }
+
+    _getUrlForHash() {
+        return this.url || this.mp3_url;
+    }
+
+    async _performSave(savePath, filename, verbose, downloadType = 'both') {
+        const results = {};
+        const tasks = [];
+
+        if ((downloadType === 'audio' || downloadType === 'both') && this.mp3_url) {
+            tasks.push(this._downloadWithPolling(this.mp3_url, savePath, filename, '.mp3', verbose, 'audio'));
+            if (this.mp3_thumbnail) {
+                tasks.push(this._downloadThumbnail(this.mp3_thumbnail, savePath, filename + '_audio_thumb', verbose, 'audio_thumbnail'));
+            }
+        }
+
+        if ((downloadType === 'video' || downloadType === 'both') && this.url) {
+            tasks.push(this._downloadWithPolling(this.url, savePath, filename, '.mp4', verbose, 'video'));
+            if (this.thumbnail) {
+                tasks.push(this._downloadThumbnail(this.thumbnail, savePath, filename + '_video_thumb', verbose, 'video_thumbnail'));
+            }
+        }
+
+        const downloaded = await Promise.all(tasks);
+        for (const [key, filePath] of downloaded) {
+            results[key] = filePath;
+        }
+        return results;
+    }
+
+    async _downloadWithPolling(url, savePath, filename, ext, verbose, key) {
+        while (true) {
+            const filePath = await this._downloadFile(url, savePath, filename, ext, verbose);
+            if (filePath === '206') {
+                if (verbose) console.info(`Media (${key}) still generating (206), retrying in 10s...`);
+                await sleep(10000);
+            } else {
+                return [key, filePath];
+            }
+        }
+    }
+
+    async _downloadThumbnail(url, savePath, filename, verbose, key) {
+        try {
+            const filePath = await this._downloadFile(url, savePath, filename, '.jpg', verbose);
+            return [key, filePath];
+        } catch (e) {
+            if (verbose) console.warn(`Failed to save thumbnail (${key}): ${e.message}`);
+            return [key, null];
+        }
+    }
+
+    repr() {
+        const urls = [];
+        if (this.url) urls.push(`mp4=${this.url}`);
+        if (this.mp3_url) urls.push(`mp3=${this.mp3_url}`);
+        return `GeneratedMedia(title=${this.title}, urls=${urls.join(', ')})`;
+    }
+}
+
+module.exports = { Video, GeneratedVideo, GeneratedMedia };

package/utils/accessToken.js

@@ -24,8 +24,12 @@ function parseCookies(headers, base = {}) {
 
 function parseProxy(str) {
     if (!str) return undefined;
-    try { const u = new URL(str); return { protocol: u.protocol.replace(':', ''), host: u.hostname, port: parseInt(u.port) }; }
-    catch { return undefined; }
+    try {
+        const u = new URL(str);
+        return { protocol: u.protocol.replace(':', ''), host: u.hostname, port: parseInt(u.port) };
+    } catch {
+        return undefined;
+    }
 }
 
 function cacheDir() {
@@ -44,8 +48,10 @@ async function sendInitRequest(cookies, proxy = null) {
     const snlm0e = (t.match(/"SNlM0e":\s*"(.*?)"/) || [])[1] || null;
     const cfb2h = (t.match(/"cfb2h":\s*"(.*?)"/) || [])[1] || null;
     const fdrfje = (t.match(/"FdrFJe":\s*"(.*?)"/) || [])[1] || null;
-    if (!snlm0e && !cfb2h && !fdrfje) throw new AuthError('Cookies invalid.');
-    return [snlm0e, cfb2h, fdrfje, parseCookies(res.headers, cookies)];
+    const language = (t.match(/"TuX5cc":\s*"(.*?)"/) || [])[1] || null;
+    const pushId = (t.match(/"qKIAYe":\s*"(.*?)"/) || [])[1] || null;
+    if (!snlm0e && !cfb2h && !fdrfje && !language && !pushId) throw new AuthError('Cookies invalid.');
+    return [snlm0e, cfb2h, fdrfje, language, pushId, parseCookies(res.headers, cookies)];
 }
 
 async function getAccessToken(baseCookies, proxy = null, verbose = false) {
@@ -59,8 +65,9 @@ async function getAccessToken(baseCookies, proxy = null, verbose = false) {
     const jar = (base, extra = {}) => ({ ...extraCookies, ...base, ...extra });
     const dir = cacheDir();
 
-    if (baseCookies['__Secure-1PSID'])
+    if (baseCookies['__Secure-1PSID']) {
         tasks.push(sendInitRequest(jar(baseCookies), proxy));
+    }
 
     const psid = baseCookies['__Secure-1PSID'];
     if (psid) {
@@ -84,8 +91,9 @@ async function getAccessToken(baseCookies, proxy = null, verbose = false) {
         if (validCaches === 0 && verbose) console.debug('Skipping cached cookies. No valid caches found.');
     }
 
-    if (!tasks.length)
+    if (!tasks.length) {
         throw new AuthError('No valid cookies available. Please pass __Secure-1PSID and optionally __Secure-1PSIDTS.');
+    }
 
     let lastErr;
     for (let i = 0; i < tasks.length; i++) {
@@ -102,4 +110,4 @@ async function getAccessToken(baseCookies, proxy = null, verbose = false) {
     throw new AuthError(`Failed to initialize client. (Failed attempts: ${tasks.length})`);
 }
 
-module.exports = { getAccessToken, sendInitRequest, cookieStr, parseCookies, parseProxy, cacheDir };
+module.exports = { getAccessToken, sendInitRequest, cookieStr, parseCookies, parseProxy, cacheDir };