gemini-reverse 1.0.5 → 1.0.7

package/constants.js

@@ -9,11 +9,11 @@ const ARTIFACTS_RE = /http:\/\/googleusercontent\.com\/\w+\/\d+\n*/g;
 const DEFAULT_METADATA = ['', '', '', null, null, null, null, null, null, ''];
 const MODEL_HEADER_KEY = 'x-goog-ext-525001261-jspb';
 
-function buildModelHeader(modelId, capacityTail) {
+function buildModelHeader(modelId, capacityTail, modelNumber = 1) {
     return {
-        [MODEL_HEADER_KEY]: `[1,null,null,null,"${modelId}",null,null,0,[4],null,null,${capacityTail}]`,
+        [MODEL_HEADER_KEY]: `[1,null,null,null,"${modelId}",null,null,0,[4,5,6,8],null,null,${capacityTail},null,null,${modelNumber}]`,
         'x-goog-ext-73010989-jspb': '[0]',
-        'x-goog-ext-73010990-jspb': '[0]',
+        'x-goog-ext-73010990-jspb': '[0,0,0]',
     };
 }
 
@@ -29,22 +29,56 @@ const Endpoint = {
 const GRPC = {
     LIST_CHATS: 'MaZiqc',
     READ_CHAT: 'hNvQHb',
+    GET_CONVERSATION_TURN: 'EqPOKe',
     DELETE_CHAT_1: 'GzXR5e',
     DELETE_CHAT_2: 'qWymEb',
+    UPDATE_CONVERSATION: 'MUAZcd',
+    MARK_LAST_CONVERSATION_TURN: 'kOWVAe',
+    GENERATE_HEADLINE: 'ukz1Fe',
+
     LIST_GEMS: 'CNgdBe',
     CREATE_GEM: 'oMH3Zd',
+    GET_GEM: 'HcT8bb',
     UPDATE_GEM: 'kHv0Vd',
     DELETE_GEM: 'UXcSJb',
+    DELETE_GEM_AND_CONVERSATIONS: 'Nwkn9',
+
+    CREATE_TASK: 'Jba3ib',
+    GET_TASK: 'kwDCne',
+    GET_ALL_TASKS: 'XPSWpd',
+    GET_TASKS_IN_CONVERSATION: 'qWymEb',
+    GET_CANDIDATES: 'PCck7e',
+    LIST_DISCOVERY_CARDS: 'ku4Jyf',
+    GET_DISCOVERY_CARD: 'oApPWc',
+    LIST_DISCOVERY_BANNERS: 'Te6DCf',
+
     DEEP_RESEARCH_STATUS: 'kwDCne',
     DEEP_RESEARCH_PREFS: 'L5adhe',
     DEEP_RESEARCH_BOOTSTRAP: 'ku4Jyf',
     DEEP_RESEARCH_MODEL_STATE: 'qpEbW',
     DEEP_RESEARCH_CAPS: 'aPya6c',
     DEEP_RESEARCH_ACK: 'PCck7e',
+
+    LIST_GEMINI_APP_ARTIFACTS: 'jGArJ',
+    DELETE_GEMINI_APP_ARTIFACTS: 'PGX16d',
+
+    LIST_MEMORIES: 'ZKcapf',
+    CREATE_MEMORY: 'xVRQX',
+    UPDATE_MEMORY: 'gSnMcd',
+    DELETE_MEMORY: 'Ok9j9b',
+    DELETE_ALL_MEMORIES: 'YgU2Cc',
+
     GET_USER_STATUS: 'otAQ7b',
     LIST_MODELS: 'otAQ7b',
+    CHECK_GEMINI_QUOTA: 'qpEbW',
+    CHECK_QUOTA: 'aPya6c',
     GET_FULL_SIZE_IMAGE: 'c8o8Fe',
+    GET_ABUSE_STATUS: 'GPRiHf',
+    UPDATE_USER_PREFERENCES: 'L5adhe',
+    READ_USER_PREFERENCES: 'ESY5D',
     BARD_SETTINGS: 'ESY5D',
+    CONTINUE_SHARED_CONVERSATION: 'ra9Swb',
+    GET_USAGE_INFO: 'jSf9Qc',
 };
 
 const Headers = {
@@ -66,67 +100,69 @@ const Headers = {
     },
     UPLOAD: { 'X-Tenant-Id': 'bard-storage' },
     BATCH_EXEC: {
-        'x-goog-ext-525001261-jspb': '[1,null,null,null,null,null,null,null,[4]]',
+        'x-goog-ext-525001261-jspb': '[1,null,null,null,null,null,null,null,[4,5,6,8],null,null,null,null,null,null,null]',
         'x-goog-ext-73010989-jspb': '[0]',
     },
 };
 
 const _MODEL_KEYS = [
-    'UNSPECIFIED', 'BASIC_PRO', 'BASIC_FLASH', 'BASIC_THINKING',
-    'PLUS_PRO', 'PLUS_FLASH', 'PLUS_THINKING',
-    'ADVANCED_PRO', 'ADVANCED_FLASH', 'ADVANCED_THINKING',
+    'UNSPECIFIED',
+    'BASIC_PRO', 'BASIC_FLASH', 'BASIC_LITE',
+    'PLUS_PRO', 'PLUS_FLASH', 'PLUS_LITE',
+    'ADVANCED_PRO', 'ADVANCED_FLASH', 'ADVANCED_LITE',
 ];
 
 const Model = {
     UNSPECIFIED: { model_name: 'unspecified', model_header: {}, advanced_only: false },
     BASIC_PRO: {
         model_name: 'gemini-3-pro',
-        model_header: buildModelHeader('9d8ca3786ebdfbea', 1),
+        model_header: buildModelHeader('9d8ca3786ebdfbea', 1, 3),
         advanced_only: false,
     },
     BASIC_FLASH: {
         model_name: 'gemini-3-flash',
-        model_header: buildModelHeader('fbb127bbb056c959', 1),
+        model_header: buildModelHeader('fbb127bbb056c959', 1, 1),
         advanced_only: false,
     },
-    BASIC_THINKING: {
-        model_name: 'gemini-3-flash-thinking',
-        model_header: buildModelHeader('5bf011840784117a', 1),
+    BASIC_LITE: {
+        model_name: 'gemini-3-lite',
+        model_header: buildModelHeader('cf41b0e0dd7d53e5', 1, 6),
         advanced_only: false,
     },
     PLUS_PRO: {
         model_name: 'gemini-3-pro-plus',
-        model_header: buildModelHeader('e6fa609c3fa255c0', 4),
+        model_header: buildModelHeader('e6fa609c3fa255c0', 4, 3),
         advanced_only: true,
     },
     PLUS_FLASH: {
         model_name: 'gemini-3-flash-plus',
-        model_header: buildModelHeader('56fdd199312815e2', 4),
+        model_header: buildModelHeader('56fdd199312815e2', 4, 1),
         advanced_only: true,
     },
-    PLUS_THINKING: {
-        model_name: 'gemini-3-flash-thinking-plus',
-        model_header: buildModelHeader('e051ce1aa80aa576', 4),
+    PLUS_LITE: {
+        model_name: 'gemini-3-lite-plus',
+        model_header: buildModelHeader('8c46e95b1a07cecc', 4, 6),
         advanced_only: true,
     },
     ADVANCED_PRO: {
         model_name: 'gemini-3-pro-advanced',
-        model_header: buildModelHeader('e6fa609c3fa255c0', 2),
+        model_header: buildModelHeader('e6fa609c3fa255c0', 2, 3),
         advanced_only: true,
     },
     ADVANCED_FLASH: {
         model_name: 'gemini-3-flash-advanced',
-        model_header: buildModelHeader('56fdd199312815e2', 2),
+        model_header: buildModelHeader('56fdd199312815e2', 2, 1),
         advanced_only: true,
     },
-    ADVANCED_THINKING: {
-        model_name: 'gemini-3-flash-thinking-advanced',
-        model_header: buildModelHeader('e051ce1aa80aa576', 2),
+    ADVANCED_LITE: {
+        model_name: 'gemini-3-lite-advanced',
+        model_header: buildModelHeader('8c46e95b1a07cecc', 2, 6),
         advanced_only: true,
     },
     fromName(name) {
+        const lower = name.toLowerCase();
         for (const k of _MODEL_KEYS) {
-            if (Model[k].model_name === name) return Model[k];
+            if (Model[k].model_name === lower) return Model[k];
         }
         const names = _MODEL_KEYS.map(k => Model[k].model_name).join(', ');
         throw new Error(`Unknown model name: ${name}. Available: ${names}`);

package/index.d.ts

@@ -18,7 +18,7 @@ export interface ModelDict {
 
 export type ModelInput = string | ModelDef | ModelDict | AvailableModel | null;
 
-export declare function buildModelHeader(modelId: string, capacityTail: string | number): ModelHeader;
+export declare function buildModelHeader(modelId: string, capacityTail: string | number, modelNumber?: number): ModelHeader;
 
 export declare const MODEL_HEADER_KEY: string;
 export declare const STREAMING_FLAG_INDEX: number;
@@ -125,6 +125,7 @@ export declare class AvailableModel {
     description: string;
     capacity: number;
     capacity_field: number;
+    model_number: number;
     is_available: boolean;
     constructor(opts: {
         model_id: string;
@@ -133,6 +134,7 @@ export declare class AvailableModel {
         description: string;
         capacity: number;
         capacity_field?: number;
+        model_number?: number;
         is_available?: boolean;
     });
     get model_header(): ModelHeader;
@@ -141,6 +143,7 @@ export declare class AvailableModel {
     repr(): string;
     static computeCapacity(tierFlags: number[], capabilityFlags: number[]): [number, number];
     static buildModelIdNameMapping(): Record<string, string>;
+    static buildModelIdNumberMapping(): Record<string, number>;
 }
 
 export interface ImageSaveOptions {
@@ -417,6 +420,7 @@ export interface GenerateOptions {
     chat?: ChatSession | null;
     temporary?: boolean;
     deep_research?: boolean;
+    extended_thinking?: boolean;
 }
 
 export interface StartChatOptions {
@@ -430,7 +434,6 @@ export interface StartChatOptions {
 
 export interface FetchGemsOptions {
     includeHidden?: boolean;
-    language?: string;
 }
 
 export interface CreateGemOptions {
@@ -462,6 +465,9 @@ export declare class GeminiClient {
     refreshInterval: number;
     verbose: boolean;
     watchdogTimeout: number;
+    readonly quotas: Record<string, Record<string, unknown>>;
+    readonly usageInfo: Record<string, unknown>;
+    readonly abuseStatus: { is_clean: boolean; status_code: number | null; signal: unknown } | null;
 
     constructor(opts?: GeminiClientOptions);
 
@@ -509,6 +515,7 @@ export interface SendMessageOptions {
     files?: (string | Buffer)[] | null;
     temporary?: boolean;
     deep_research?: boolean;
+    extended_thinking?: boolean;
 }
 
 export declare class ChatSession {

package/index.js

@@ -11,6 +11,7 @@ const {
     AuthError, APIError, ImageGenerationError, GeminiError, TimeoutError,
     UsageLimitExceeded, ModelInvalid, TemporarilyBlocked,
 } = require('./exceptions');
+const { StreamingFrameParser } = require('./utils/parsing');
 const {
     Candidate, ChatHistory, ChatTurn, ChatInfo, Gem, GemJar, RPCData,
     Image, WebImage, GeneratedImage, ModelOutput,
@@ -61,4 +62,5 @@ module.exports = {
     GeneratedVideo,
     GeneratedMedia,
     AvailableModel,
+    StreamingFrameParser,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gemini-reverse",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "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

@@ -3,13 +3,14 @@
 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 } = {}) {
+    constructor({ model_id, model_name, display_name, description, capacity, capacity_field = 12, model_number = 1, 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.model_number = model_number;
         this.is_available = is_available;
     }
 
@@ -20,7 +21,7 @@ class AvailableModel {
         } else {
             tail = String(this.capacity);
         }
-        return buildModelHeader(this.model_id, tail);
+        return buildModelHeader(this.model_id, tail, this.model_number);
     }
 
     get advanced_only() {
@@ -47,9 +48,9 @@ class AvailableModel {
     static buildModelIdNameMapping() {
         const result = {};
         const keys = [
-            'BASIC_PRO', 'BASIC_FLASH', 'BASIC_THINKING',
-            'PLUS_PRO', 'PLUS_FLASH', 'PLUS_THINKING',
-            'ADVANCED_PRO', 'ADVANCED_FLASH', 'ADVANCED_THINKING',
+            'BASIC_PRO', 'BASIC_FLASH', 'BASIC_LITE',
+            'PLUS_PRO', 'PLUS_FLASH', 'PLUS_LITE',
+            'ADVANCED_PRO', 'ADVANCED_FLASH', 'ADVANCED_LITE',
         ];
         for (const key of keys) {
             const member = Model[key];
@@ -71,6 +72,32 @@ class AvailableModel {
         }
         return result;
     }
+
+    static buildModelIdNumberMapping() {
+        const result = {};
+        const keys = [
+            'BASIC_PRO', 'BASIC_FLASH', 'BASIC_LITE',
+            'PLUS_PRO', 'PLUS_FLASH', 'PLUS_LITE',
+            'ADVANCED_PRO', 'ADVANCED_FLASH', 'ADVANCED_LITE',
+        ];
+        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];
+                const modelNumber = parsed && parsed[parsed.length - 1];
+                if (modelId && typeof modelNumber === 'number' && !(modelId in result)) {
+                    result[modelId] = modelNumber;
+                }
+            } catch {
+                continue;
+            }
+        }
+        return result;
+    }
 }
 
 module.exports = { AvailableModel };

package/types/candidate.js

@@ -5,12 +5,26 @@ const { WebImage, GeneratedImage } = require('./image');
 function decodeHtml(str) {
     if (!str) return str;
     return str
+        .replace(/&#(\d+);/g, (_, n) => String.fromCodePoint(parseInt(n, 10)))
+        .replace(/&#x([0-9a-f]+);/gi, (_, h) => String.fromCodePoint(parseInt(h, 16)))
         .replace(/&/g, '&')
         .replace(/&lt;/g, '<')
         .replace(/&gt;/g, '>')
         .replace(/&quot;/g, '"')
-        .replace(/&#39;/g, "'")
-        .replace(/&apos;/g, "'");
+        .replace(/&apos;/g, "'")
+        .replace(/&nbsp;/g, ' ')
+        .replace(/&copy;/g, '©')
+        .replace(/&reg;/g, '®')
+        .replace(/&trade;/g, '™')
+        .replace(/&mdash;/g, '—')
+        .replace(/&ndash;/g, '–')
+        .replace(/&hellip;/g, '…')
+        .replace(/&laquo;/g, '«')
+        .replace(/&raquo;/g, '»')
+        .replace(/&ldquo;/g, '“')
+        .replace(/&rdquo;/g, '”')
+        .replace(/&lsquo;/g, '‘')
+        .replace(/&rsquo;/g, '’');
 }
 
 class Candidate {

package/types/video.js

@@ -45,6 +45,10 @@ class Video {
         const proxyConfig = this.proxy ? this._parseProxy(this.proxy) : undefined;
         const res = await axios.get(url, {
             responseType: 'arraybuffer',
+            headers: {
+                'Origin': 'https://gemini.google.com',
+                'Referer': 'https://gemini.google.com/',
+            },
             ...(proxyConfig ? { proxy: proxyConfig } : {}),
             validateStatus: null,
         });

package/utils/index.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const { getAccessToken, sendInitRequest, cookieStr, parseCookies, parseProxy, cacheDir } = require('./accessToken');
-const { getDeltaByFpLen, getCleanText, getNestedValue, parseResponseByFrame, extractJsonFromResponse } = require('./parsing');
+const { getDeltaByFpLen, getCleanText, getNestedValue, parseResponseByFrame, extractJsonFromResponse, StreamingFrameParser } = require('./parsing');
 const { rotate1psidts } = require('./rotate');
 const { uploadFile, parseFileName, generateRandomName } = require('./upload');
 const {
@@ -28,6 +28,7 @@ module.exports = {
     getNestedValue,
     parseResponseByFrame,
     extractJsonFromResponse,
+    StreamingFrameParser,
     rotate1psidts,
     uploadFile,
     parseFileName,

package/utils/parsing.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const FLICKER_ESC_RE = /\\+[`*_~].*$/;
+const LENGTH_MARKER_RE = /^(\d+)\n/;
 
 function getCleanText(s) {
     if (!s) return '';
@@ -90,45 +91,121 @@ function getNestedValue(data, path, defaultVal = null) {
     return cur != null ? cur : defaultVal;
 }
 
-function parseResponseByFrame(content) {
-    let pos = 0;
-    const frames = [];
-    while (pos < content.length) {
-        while (pos < content.length && /\s/.test(content[pos])) pos++;
-        if (pos >= content.length) break;
-        const m = /^(\d+)\n/.exec(content.slice(pos));
-        if (!m) break;
-        const len = parseInt(m[1]);
-        const start = pos + m[1].length;
-        let chars = 0, units = 0, idx = start;
-        while (units < len && idx < content.length) {
-            const cp = content.codePointAt(idx);
+class StreamingFrameParser {
+    constructor() {
+        this.buffer = '';
+        this.expectedUnits = null;
+        this.payloadStart = 0;
+        this.scannedChars = 0;
+        this.scannedUnits = 0;
+        this.prefixChecked = false;
+    }
+
+    reset() {
+        this.buffer = '';
+        this._resetFrameState();
+        this.prefixChecked = false;
+    }
+
+    feed(content) {
+        if (typeof content !== 'string') throw new TypeError(`Expected string, got ${typeof content}`);
+        if (content) this.buffer += content;
+        this._stripPrefixOnce();
+
+        const parsed = [];
+        while (true) {
+            if (this.expectedUnits === null && !this._readLengthMarker()) break;
+            if (this.expectedUnits === null) break;
+
+            this._scanAvailablePayload();
+            if (this.scannedUnits < this.expectedUnits) break;
+
+            const endPos = this.payloadStart + this.scannedChars;
+            const chunk = this.buffer.slice(this.payloadStart, endPos);
+            this.buffer = this.buffer.slice(endPos);
+            this._resetFrameState();
+
+            if (!chunk.trim()) continue;
+
+            try {
+                const p = JSON.parse(chunk);
+                if (Array.isArray(p)) parsed.push(...p);
+                else parsed.push(p);
+            } catch {}
+        }
+        return parsed;
+    }
+
+    flush() {
+        return this.feed('');
+    }
+
+    _resetFrameState() {
+        this.expectedUnits = null;
+        this.payloadStart = 0;
+        this.scannedChars = 0;
+        this.scannedUnits = 0;
+    }
+
+    _stripPrefixOnce() {
+        if (this.prefixChecked) return;
+        const prefix = ")]}'";
+        if (this.buffer.length < prefix.length && prefix.startsWith(this.buffer)) return;
+        if (this.buffer.startsWith(prefix)) {
+            this.buffer = this.buffer.slice(prefix.length).trimStart();
+        }
+        this.prefixChecked = true;
+    }
+
+    _readLengthMarker() {
+        let pos = 0;
+        while (pos < this.buffer.length && /\s/.test(this.buffer[pos])) pos++;
+        if (pos) {
+            this.buffer = this.buffer.slice(pos);
+        }
+        if (!this.buffer.length) return false;
+
+        const m = LENGTH_MARKER_RE.exec(this.buffer);
+        if (!m) return false;
+
+        const lenStr = m[1];
+        this.expectedUnits = parseInt(lenStr, 10);
+        this.payloadStart = lenStr.length;
+        this.scannedChars = 0;
+        this.scannedUnits = 0;
+        return true;
+    }
+
+    _scanAvailablePayload() {
+        if (this.expectedUnits === null) return;
+        let idx = this.payloadStart + this.scannedChars;
+        const limit = this.buffer.length;
+
+        while (this.scannedUnits < this.expectedUnits && idx < limit) {
+            const cp = this.buffer.codePointAt(idx);
             const u = cp > 0xFFFF ? 2 : 1;
-            if (units + u > len) break;
-            units += u;
-            chars += cp > 0xFFFF ? 2 : 1;
+            if (this.scannedUnits + u > this.expectedUnits) break;
+            this.scannedUnits += u;
+            this.scannedChars += cp > 0xFFFF ? 2 : 1;
             idx += cp > 0xFFFF ? 2 : 1;
         }
-        if (units < len) break;
-        const end = start + chars;
-        const chunk = content.slice(start, end).trim();
-        pos = end;
-        if (!chunk) continue;
-        try {
-            const parsed = JSON.parse(chunk);
-            if (Array.isArray(parsed)) frames.push(...parsed);
-            else frames.push(parsed);
-        } catch {}
     }
-    return [frames, content.slice(pos)];
+}
+
+function parseResponseByFrame(content) {
+    const parser = new StreamingFrameParser();
+    const frames = parser.feed(content);
+    frames.push(...parser.flush());
+    return [frames, parser.buffer];
 }
 
 function extractJsonFromResponse(text) {
     if (typeof text !== 'string') throw new TypeError(`Expected string, got ${typeof text}`);
-    let c = text.startsWith(")]}'") ? text.slice(4) : text;
-    c = c.trimStart();
-    const [r] = parseResponseByFrame(c);
-    if (r.length) return r;
+    const parser = new StreamingFrameParser();
+    const result = parser.feed(text);
+    result.push(...parser.flush());
+    if (result.length) return result;
+    const c = text.startsWith(")]}'") ? text.slice(4).trimStart() : text.trimStart();
     try {
         const p = JSON.parse(c.trim());
         return Array.isArray(p) ? p : [p];
@@ -145,4 +222,4 @@ function extractJsonFromResponse(text) {
     throw new Error('Could not find valid JSON in response.');
 }
 
-module.exports = { getCleanText, getDeltaByFpLen, getNestedValue, parseResponseByFrame, extractJsonFromResponse };
+module.exports = { getCleanText, getDeltaByFpLen, getNestedValue, parseResponseByFrame, extractJsonFromResponse, StreamingFrameParser };

package/utils/upload.js

@@ -3,6 +3,7 @@
 const axios = require('axios');
 const fs = require('fs');
 const path = require('path');
+const mime = require('mime-types');
 const FormData = require('form-data');
 const { Endpoint, Headers } = require('../constants');
 const { parseProxy } = require('./accessToken');
@@ -21,26 +22,36 @@ function parseFileName(file) {
     return generateRandomName();
 }
 
-async function uploadFile(file, proxy = null, filename = null) {
+async function uploadFile(file, proxy = null, pushId = '', cookies = {}) {
     let content, fname;
 
     if (typeof file === 'string') {
         const fp = path.resolve(file);
         if (!fs.existsSync(fp)) throw new Error(`${fp} is not a valid file.`);
-        fname = filename || path.basename(fp);
+        fname = path.basename(fp);
         content = fs.readFileSync(fp);
     } else if (Buffer.isBuffer(file)) {
         content = file;
-        fname = filename || generateRandomName();
+        fname = generateRandomName();
     } else {
         throw new Error(`Unsupported file type: ${typeof file}`);
     }
 
+    const contentType = mime.lookup(fname) || 'application/octet-stream';
+
     const form = new FormData();
-    form.append('file', content, { filename: fname });
+    form.append('file', content, { filename: fname, contentType });
+
+    const cookieStr = Object.entries(cookies).map(([k, v]) => `${k}=${v}`).join('; ');
 
     const res = await axios.post(Endpoint.UPLOAD, form, {
-        headers: { ...Headers.UPLOAD, ...form.getHeaders() },
+        headers: {
+            ...Headers.REFERER,
+            ...Headers.UPLOAD,
+            ...form.getHeaders(),
+            'Push-ID': pushId,
+            ...(cookieStr ? { 'Cookie': cookieStr } : {}),
+        },
         maxRedirects: 5,
         ...(proxy ? { proxy: parseProxy(proxy) } : {}),
     });
@@ -48,4 +59,4 @@ async function uploadFile(file, proxy = null, filename = null) {
     return res.data;
 }
 
-module.exports = { uploadFile, parseFileName, generateRandomName };
+module.exports = { uploadFile, parseFileName, generateRandomName };