gemini-reverse 1.0.2 → 1.0.3

package/client.js

@@ -1,19 +1,32 @@
 'use strict';
 
 const axios = require('axios');
+const crypto = require('crypto');
 const { v4: uuidv4 } = require('uuid');
-const { Endpoint, GRPC, Headers, Model, ErrorCode, TEMPORARY_CHAT_FLAG_INDEX } = require('./constants');
-const { APIError, GeminiError, TimeoutError, UsageLimitExceeded, ModelInvalid, TemporarilyBlocked } = require('./exceptions');
+const {
+    Endpoint, GRPC, Headers, Model, AccountStatus, ErrorCode,
+    TEMPORARY_CHAT_FLAG_INDEX, STREAMING_FLAG_INDEX, GEM_FLAG_INDEX,
+    CARD_CONTENT_RE, ARTIFACTS_RE, DEFAULT_METADATA, MODEL_HEADER_KEY,
+} = require('./constants');
+const {
+    APIError, GeminiError, TimeoutError, UsageLimitExceeded, ModelInvalid, TemporarilyBlocked,
+} = require('./exceptions');
 const { ChatMixin } = require('./components/chatMixin');
 const { GemMixin } = require('./components/gemMixin');
+const { ResearchMixin } = require('./components/researchMixin');
+const { AvailableModel } = require('./types/availablemodel');
 const { Candidate } = require('./types/candidate');
 const { ModelOutput } = require('./types/modeloutput');
 const { WebImage, GeneratedImage } = require('./types/image');
+const { GeneratedVideo, GeneratedMedia } = require('./types/video');
+const { DeepResearchPlan } = require('./types/research');
 const { RPCData } = require('./types/grpc');
+const { Gem } = require('./types/gem');
 const { getAccessToken, cookieStr, parseCookies, parseProxy } = require('./utils/accessToken');
 const { rotate1psidts } = require('./utils/rotate');
 const { uploadFile, parseFileName } = require('./utils/upload');
 const { getDeltaByFpLen, getNestedValue, parseResponseByFrame, extractJsonFromResponse } = require('./utils/parsing');
+const { extractDeepResearchPlan } = require('./utils/research');
 
 function sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
 
@@ -21,11 +34,17 @@ function applyMixins(Base, ...mixins) {
     for (const mixin of mixins) {
         for (const key of Object.getOwnPropertyNames(mixin.prototype)) {
             if (key === 'constructor') continue;
-            Object.defineProperty(Base.prototype, key, Object.getOwnPropertyDescriptor(mixin.prototype, key));
+            Object.defineProperty(
+                Base.prototype,
+                key,
+                Object.getOwnPropertyDescriptor(mixin.prototype, key),
+            );
         }
     }
 }
 
+const BARD_SETTINGS_PAYLOAD = '[[["adaptive_device_responses_enabled","advanced_mode_theme_override_triggered","advanced_zs_upsell_dismissal_count","advanced_zs_upsell_last_dismissed","ai_transparency_notice_dismissed","audio_overview_discovery_dismissal_count","audio_overview_discovery_last_dismissed","bard_in_chrome_link_sharing_enabled","bard_sticky_mode_disabled_count","canvas_create_discovery_tooltip_seen_count","combined_files_button_tag_seen_count","indigo_banner_explicit_dismissal_count","indigo_banner_impression_count","indigo_banner_last_seen_sec","current_popup_id","deep_research_has_seen_file_upload_tooltip","deep_research_model_update_disclaimer_display_count","default_bot_id","disabled_discovery_card_feature_ids","disabled_model_discovery_tooltip_feature_ids","disabled_mode_disclaimers","disabled_new_model_badge_mode_ids","disabled_settings_discovery_tooltip_feature_ids","disablement_disclaimer_last_dismissed_sec","disable_advanced_beta_dialog","disable_advanced_beta_non_en_banner","disable_advanced_resubscribe_ui","disable_at_mentions_discovery_tooltip","disable_autorun_fact_check_u18","disable_bot_create_tips_card","disable_bot_docs_in_gems_disclaimer","disable_bot_onboarding_dialog","disable_bot_save_reminder_tips_card","disable_bot_send_prompt_tips_card","disable_bot_shared_in_drive_disclaimer","disable_bot_try_create_tips_card","disable_colab_tooltip","disable_collapsed_tool_menu_tooltip","disable_continue_discovery_tooltip","disable_debug_info_moved_tooltip_v2","disable_enterprise_mode_dialog","disable_export_python_tooltip","disable_extensions_discovery_dialog","disable_extension_one_time_badge","disable_fact_check_tooltip_v2","disable_free_file_upload_tips_card","disable_generated_image_download_dialog","disable_get_app_banner","disable_get_app_desktop_dialog","disable_googler_in_enterprise_mode","disable_human_review_disclosure","disable_ice_open_vega_editor_tooltip","disable_image_upload_tooltip","disable_legal_concern_tooltip","disable_llm_history_import_disclaimer","disable_location_popup","disable_memory_discovery","disable_memory_extraction_discovery","disable_new_conversation_dialog","disable_onboarding_experience","disable_personal_context_tooltip","disable_photos_upload_disclaimer","disable_power_up_intro_tooltip","disable_scheduled_actions_mobile_notification_snackbar","disable_storybook_listen_button_tooltip","disable_streaming_settings_tooltip","disable_take_control_disclaimer","disable_teens_only_english_language_dialog","disable_tier1_rebranding_tooltip","disable_try_advanced_mode_dialog","enable_advanced_beta_mode","enable_advanced_mode","enable_googler_in_enterprise_mode","enable_memory","enable_memory_extraction","enable_personal_context","enable_personal_context_gemini","enable_personal_context_gemini_using_photos","enable_personal_context_gemini_using_workspace","enable_personal_context_search","enable_personal_context_youtube","enable_token_streaming","enforce_default_to_fast_version","mayo_discovery_banner_dismissal_count","mayo_discovery_banner_last_dismissed_sec","gempix_discovery_banner_dismissal_count","gempix_discovery_banner_last_dismissed","get_app_banner_ack_count","get_app_banner_seen_count","get_app_mobile_dialog_ack_count","guided_learning_banner_dismissal_count","guided_learning_banner_last_dismissed","has_accepted_agent_mode_fre_disclaimer","has_received_streaming_response","has_seen_agent_mode_tooltip","has_seen_bespoke_tooltip","has_seen_deepthink_mustard_tooltip","has_seen_deepthink_v2_tooltip","has_seen_deep_think_tooltip","has_seen_first_youtube_video_disclaimer","has_seen_ggo_tooltip","has_seen_image_grams_discovery_banner","has_seen_image_preview_in_input_area_tooltip","has_seen_kallo_discovery_banner","has_seen_kallo_tooltip","has_seen_model_picker_in_input_area_tooltip","has_seen_model_tooltip_in_input_area_for_gempix","has_seen_redo_with_gempix2_tooltip","has_seen_veograms_discovery_banner","has_seen_video_generation_discovery_banner","is_imported_chats_panel_open_by_default","jumpstart_onboarding_dismissal_count","last_dismissed_deep_research_implicit_invite","last_dismissed_discovery_feature_implicit_invites","last_dismissed_immersives_canvas_implicit_invite","last_dismissed_immersive_share_disclaimer_sec","last_dismissed_strike_timestamp_sec","last_dismissed_zs_student_aip_banner_sec","last_get_app_banner_ack_timestamp_sec","last_get_app_mobile_dialog_ack_timestamp_sec","last_human_review_disclosure_ack","last_selected_mode_id_in_embedded","last_selected_mode_id_on_web","last_two_up_activation_timestamp_sec","last_winter_olympics_interaction_timestamp_sec","memory_extracted_greeting_name","mini_gemini_tos_closed","mode_switcher_soft_badge_disabled_ids","mode_switcher_soft_badge_seen_count","personalization_first_party_onboarding_cross_surface_clicked","personalization_first_party_onboarding_cross_surface_seen_count","personalization_one_p_discovery_card_seen_count","personalization_one_p_discovery_last_consented","personalization_zero_state_card_last_interacted","personalization_zero_state_card_seen_count","popup_zs_visits_cooldown","require_reconsent_setting_for_personalization_banner_seen_count","show_debug_info","side_nav_open_by_default","student_verification_dismissal_count","student_verification_last_dismissed","task_viewer_cc_banner_dismissed_count","task_viewer_cc_banner_dismissed_time_sec","tool_menu_new_badge_disabled_ids","tool_menu_new_badge_impression_counts","tool_menu_soft_badge_disabled_ids","tool_menu_soft_badge_impression_counts","upload_disclaimer_last_consent_time_sec","viewed_student_aip_upsell_campaign_ids","voice_language","voice_name","web_and_app_activity_enabled","wellbeing_nudge_notice_last_dismissed_sec","zs_student_aip_banner_dismissal_count"]]]';
+
 class GeminiClient {
     constructor({ secure_1psid = null, secure_1psidts = null, proxy = null, cookies = {} } = {}) {
         this.cookies = { ...cookies };
@@ -34,6 +53,9 @@ class GeminiClient {
         this.accessToken = null;
         this.buildLabel = null;
         this.sessionId = null;
+        this.language = 'en';
+        this.pushId = 'feeds/mcudyrk2a4khkz';
+        this.accountStatus = AccountStatus.AVAILABLE;
         this.timeout = 300000;
         this.autoClose = false;
         this.closeDelay = 300000;
@@ -41,9 +63,12 @@ class GeminiClient {
         this.autoRefresh = true;
         this.refreshInterval = 540000;
         this.refreshTask = null;
-        this.verbose = true;
         this.watchdogTimeout = 30000;
+        this.verbose = false;
+        this._running = false;
         this._reqid = Math.floor(Math.random() * 90000) + 10000;
+        this._modelRegistry = {};
+        this._recentChats = null;
         this._gems = null;
 
         if (secure_1psid) {
@@ -52,27 +77,46 @@ class GeminiClient {
         }
     }
 
-    async init({ timeout = 300000, autoClose = false, closeDelay = 300000, autoRefresh = true, refreshInterval = 540000, verbose = true, watchdogTimeout = 30000 } = {}) {
+    async init({
+        timeout = 300000,
+        autoClose = false,
+        closeDelay = 300000,
+        autoRefresh = true,
+        refreshInterval = 540000,
+        verbose = false,
+        watchdogTimeout = 30000,
+    } = {}) {
         if (this._running) return;
         try {
             this.verbose = verbose;
             this.watchdogTimeout = watchdogTimeout;
 
-            const [accessToken, buildLabel, sessionId, validCookies] = await getAccessToken(this.cookies, this.proxy, this.verbose);
+            const [accessToken, buildLabel, sessionId, language, pushId, validCookies] = await getAccessToken(
+                this.cookies, this.proxy, this.verbose,
+            );
+
             this.accessToken = accessToken;
             this.buildLabel = buildLabel;
             this.sessionId = sessionId;
+            this.language = language || 'en';
+            this.pushId = pushId || 'feeds/mcudyrk2a4khkz';
             this.cookies = validCookies;
             this._running = true;
+            this._reqid = Math.floor(Math.random() * 90000) + 10000;
             this.timeout = timeout;
             this.autoClose = autoClose;
             this.closeDelay = closeDelay;
 
             if (autoClose) this._resetCloseTask();
+
             this.autoRefresh = autoRefresh;
             this.refreshInterval = refreshInterval;
+
             if (this.refreshTask) { clearInterval(this.refreshTask); this.refreshTask = null; }
             if (autoRefresh) this._startAutoRefresh();
+
+            await this._initRpc();
+
             if (this.verbose) console.log('Gemini client initialized successfully.');
         } catch (e) { await this.close(); throw e; }
     }
@@ -103,7 +147,140 @@ class GeminiClient {
         }, interval);
     }
 
-    async _batchExecute(payloads, retries = 2) {
+    async _initRpc() {
+        await this._fetchUserStatus();
+        await this._sendBardSettings();
+        await this._sendBardActivity();
+        await this._fetchRecentChats();
+    }
+
+    async _fetchUserStatus() {
+        try {
+            const response = await this._batchExecute([
+                new RPCData({ rpcid: GRPC.GET_USER_STATUS, payload: '[]' }),
+            ]);
+
+            const responseJson = extractJsonFromResponse(response.data);
+
+            for (const part of responseJson) {
+                const partBodyStr = getNestedValue(part, [2]);
+                if (!partBodyStr) continue;
+                let partBody;
+                try { partBody = JSON.parse(partBodyStr); } catch { continue; }
+
+                const statusCode = getNestedValue(partBody, [14]);
+                this.accountStatus = AccountStatus.fromStatusCode(statusCode);
+
+                if (this.accountStatus !== AccountStatus.AVAILABLE) {
+                    console.warn(`Account status: ${this.accountStatus.name} - ${this.accountStatus.description}`);
+                    if ([
+                        AccountStatus.LOCATION_REJECTED,
+                        AccountStatus.ACCOUNT_REJECTED,
+                        AccountStatus.ACCESS_TEMPORARILY_UNAVAILABLE,
+                        AccountStatus.ACCOUNT_REJECTED_BY_GUARDIAN,
+                        AccountStatus.GUARDIAN_APPROVAL_REQUIRED,
+                    ].includes(this.accountStatus)) continue;
+                }
+
+                const modelsList = getNestedValue(partBody, [15]);
+                if (!Array.isArray(modelsList)) continue;
+
+                const tierFlags = (() => {
+                    const tf = getNestedValue(partBody, [16], []);
+                    return Array.isArray(tf) ? tf : [];
+                })();
+                const capabilityFlags = (() => {
+                    const cf = getNestedValue(partBody, [17], []);
+                    return Array.isArray(cf) ? cf : [];
+                })();
+                const [capacity, capacityField] = AvailableModel.computeCapacity(tierFlags, capabilityFlags);
+                const idNameMapping = AvailableModel.buildModelIdNameMapping();
+
+                for (const modelData of modelsList) {
+                    if (!Array.isArray(modelData)) continue;
+                    const modelId = getNestedValue(modelData, [0], '');
+                    const displayName = getNestedValue(modelData, [1], '');
+                    const description = getNestedValue(modelData, [2], '');
+
+                    if (modelId && displayName) {
+                        let isModelAvailable = true;
+                        if (this.accountStatus === AccountStatus.UNAUTHENTICATED) {
+                            if (modelId !== Model.modelId(Model.BASIC_FLASH)) {
+                                isModelAvailable = false;
+                            }
+                        }
+                        const model = new AvailableModel({
+                            model_id: modelId,
+                            model_name: idNameMapping[modelId] || '',
+                            display_name: displayName,
+                            description,
+                            capacity,
+                            capacity_field: capacityField,
+                            is_available: isModelAvailable,
+                        });
+                        this._modelRegistry[modelId] = model;
+                    }
+                }
+                return;
+            }
+        } catch (e) {
+            if (this.verbose) console.debug(`_fetchUserStatus failed: ${e.message}`);
+        }
+    }
+
+    async _sendBardSettings() {
+        await this._batchExecute([
+            new RPCData({ rpcid: GRPC.BARD_SETTINGS, payload: BARD_SETTINGS_PAYLOAD }),
+        ]);
+    }
+
+    async _sendBardActivity() {
+        await this._batchExecute([
+            new RPCData({ rpcid: GRPC.BARD_SETTINGS, payload: '[[["bard_activity_enabled"]]]' }),
+        ]);
+    }
+
+    listModels() {
+        const vals = Object.values(this._modelRegistry);
+        return vals.length > 0 ? vals : null;
+    }
+
+    _resolveModelByName(name) {
+        if (name in this._modelRegistry) return this._modelRegistry[name];
+        for (const m of Object.values(this._modelRegistry)) {
+            if (m.model_name === name || m.display_name === name) return m;
+        }
+        return Model.fromName(name);
+    }
+
+    _resolveEnumModel(model) {
+        if (model === Model.UNSPECIFIED) return model;
+        const headerValue = model.model_header[MODEL_HEADER_KEY];
+        if (!headerValue) return model;
+        try {
+            const parsed = JSON.parse(headerValue);
+            const modelId = parsed && parsed[4];
+            if (modelId && modelId in this._modelRegistry) return this._modelRegistry[modelId];
+        } catch {}
+        return model;
+    }
+
+    _resolveModel(model) {
+        if (!model || model === Model.UNSPECIFIED) return this._resolveEnumModel(Model.UNSPECIFIED);
+        if (model instanceof AvailableModel) return model;
+        if (typeof model === 'string') return this._resolveModelByName(model);
+        if (typeof model === 'object' && !model.model_name) return Model.fromDict(model);
+        if (typeof model === 'object' && model.model_header !== undefined) {
+            if (!(model instanceof AvailableModel)) {
+                const mid = Model.modelId(model);
+                if (mid && mid in this._modelRegistry) return this._modelRegistry[mid];
+            }
+            return model;
+        }
+        return model;
+    }
+
+    async _batchExecute(payloads, retries = 2, closeOnError = true) {
         let lastErr;
         for (let attempt = 0; attempt <= retries; attempt++) {
             try {
@@ -112,7 +289,10 @@ class GeminiClient {
 
                 const params = new URLSearchParams({
                     rpcids: payloads.map(p => p.rpcid).join(','),
-                    _reqid: String(_reqid), rt: 'c', 'source-path': '/app',
+                    hl: this.language || 'en',
+                    _reqid: String(_reqid),
+                    rt: 'c',
+                    'source-path': '/app',
                 });
                 if (this.buildLabel) params.set('bl', this.buildLabel);
                 if (this.sessionId) params.set('f.sid', this.sessionId);
@@ -122,179 +302,276 @@ class GeminiClient {
                     'f.req': JSON.stringify([payloads.map(p => p.serialize())]),
                 });
 
-                const res = await axios.post(`${Endpoint.BATCH_EXEC}?${params}`, body.toString(), {
-                    headers: { ...Headers.GEMINI, 'Cookie': cookieStr(this.cookies) },
-                    timeout: this.timeout,
-                    ...(this.proxy ? { proxy: parseProxy(this.proxy) } : {}),
-                    validateStatus: null,
-                });
+                const res = await axios.post(
+                    `${Endpoint.BATCH_EXEC}?${params}`,
+                    body.toString(),
+                    {
+                        headers: {
+                            ...Headers.GEMINI,
+                            ...Headers.BATCH_EXEC,
+                            ...Headers.SAME_DOMAIN,
+                            'Cookie': cookieStr(this.cookies),
+                        },
+                        timeout: this.timeout,
+                        ...(this.proxy ? { proxy: parseProxy(this.proxy) } : {}),
+                        validateStatus: null,
+                    },
+                );
 
                 Object.assign(this.cookies, parseCookies(res.headers));
-                if (res.status !== 200) { await this.close(); throw new APIError(`Batch execution failed with status code ${res.status}`); }
+                if (res.status !== 200) {
+                    if (closeOnError) await this.close();
+                    throw new APIError(`Batch execution failed with status code ${res.status}`);
+                }
                 return res;
-            } catch (e) { lastErr = e; if (attempt < retries) await sleep(1000 * (attempt + 1)); }
+            } catch (e) {
+                lastErr = e;
+                if (attempt < retries) await sleep(1000 * (attempt + 1));
+            }
         }
         throw lastErr;
     }
 
-    async generateContent({ prompt, files = null, model = Model.UNSPECIFIED, gem = null, chat = null, temporary = false } = {}) {
+    async generateContent({
+        prompt,
+        files = null,
+        model = Model.UNSPECIFIED,
+        gem = null,
+        chat = null,
+        temporary = false,
+        deep_research = false,
+    } = {}) {
         if (this.autoClose) this._resetCloseTask();
-        if (!(chat instanceof ChatSession && chat.cid))
-            this._reqid = Math.floor(Math.random() * 90000) + 10000;
 
         let fileData = null;
         if (files && files.length) {
-            await this._batchExecute([new RPCData({ rpcid: GRPC.BARD_ACTIVITY, payload: '[[["bard_activity_enabled"]]]' })]);
-            const uploaded = await Promise.all(files.map(f => uploadFile(f, this.proxy)));
+            await this._sendBardActivity();
+            const uploaded = await Promise.all(
+                files.map(f => uploadFile(f, this.proxy, this.pushId)),
+            );
             fileData = uploaded.map((url, i) => [[url], parseFileName(files[i])]);
         }
 
         try {
-            await this._batchExecute([new RPCData({ rpcid: GRPC.BARD_ACTIVITY, payload: '[[["bard_activity_enabled"]]]' })]);
-            const ss = { last_texts: {}, last_thoughts: {}, last_progress_time: Date.now() };
+            await this._sendBardActivity();
+            const ss = { last_texts: {}, last_thoughts: {}, last_progress_time: Date.now(), is_thinking: false, is_queueing: false };
             let output = null;
-            for await (const out of this._generate({ prompt, fileData, model, gem, chat, temporary, ss })) output = out;
+            for await (const out of this._generate({
+                prompt, fileData, model, gem, chat, temporary, ss, deep_research,
+            })) output = out;
             if (!output) throw new GeminiError('Failed to generate contents. No output data found in response.');
             if (chat instanceof ChatSession) { output.metadata = chat.metadata; chat.lastOutput = output; }
             return output;
-        } finally {}
+        } finally {
+        }
     }
 
-    async* generateContentStream({ prompt, files = null, model = Model.UNSPECIFIED, gem = null, chat = null, temporary = false } = {}) {
+    async* generateContentStream({
+        prompt,
+        files = null,
+        model = Model.UNSPECIFIED,
+        gem = null,
+        chat = null,
+        temporary = false,
+        deep_research = false,
+    } = {}) {
         if (this.autoClose) this._resetCloseTask();
-        if (!(chat instanceof ChatSession && chat.cid))
-            this._reqid = Math.floor(Math.random() * 90000) + 10000;
 
         let fileData = null;
         if (files && files.length) {
-            await this._batchExecute([new RPCData({ rpcid: GRPC.BARD_ACTIVITY, payload: '[[["bard_activity_enabled"]]]' })]);
-            const uploaded = await Promise.all(files.map(f => uploadFile(f, this.proxy)));
+            await this._sendBardActivity();
+            const uploaded = await Promise.all(
+                files.map(f => uploadFile(f, this.proxy, this.pushId)),
+            );
             fileData = uploaded.map((url, i) => [[url], parseFileName(files[i])]);
         }
 
-        await this._batchExecute([new RPCData({ rpcid: GRPC.BARD_ACTIVITY, payload: '[[["bard_activity_enabled"]]]' })]);
-        const ss = { last_texts: {}, last_thoughts: {}, last_progress_time: Date.now() };
+        await this._sendBardActivity();
+        const ss = { last_texts: {}, last_thoughts: {} };
         let output = null;
-        for await (const out of this._generate({ prompt, fileData, model, gem, chat, temporary, ss })) {
-            output = out; yield out;
+        for await (const out of this._generate({
+            prompt, fileData, model, gem, chat, temporary, ss, deep_research,
+        })) {
+            output = out;
+            yield out;
         }
         if (output && chat instanceof ChatSession) { output.metadata = chat.metadata; chat.lastOutput = output; }
     }
 
-    async* _generate({ prompt, fileData = null, model = Model.UNSPECIFIED, gem = null, chat = null, temporary = false, ss = null }, retries = 5) {
+    async* _generate({
+        prompt,
+        fileData = null,
+        model = Model.UNSPECIFIED,
+        gem = null,
+        chat = null,
+        temporary = false,
+        ss = null,
+        deep_research = false,
+    }, retries = 5) {
         if (!prompt) throw new Error('Prompt cannot be empty.');
-        if (typeof model === 'string') model = Model.fromName(model);
-        else if (model && typeof model === 'object' && !model.model_name) model = Model.fromDict(model);
+
+        model = this._resolveModel(model);
 
         for (let attempt = 0; attempt <= retries; attempt++) {
             try {
-                for await (const out of this._stream({ prompt, fileData, model, gem, chat, temporary, ss })) yield out;
+                for await (const out of this._stream({ prompt, fileData, model, gem, chat, temporary, ss, deep_research })) yield out;
                 return;
             } catch (e) {
-                if (e instanceof GeminiError || e instanceof ModelInvalid || e instanceof UsageLimitExceeded || e instanceof TemporarilyBlocked) throw e;
+                if (
+                    e instanceof GeminiError || e instanceof ModelInvalid ||
+                    e instanceof UsageLimitExceeded || e instanceof TemporarilyBlocked
+                ) throw e;
                 if (attempt >= retries) throw e;
                 await sleep(1000 * (attempt + 1));
             }
         }
     }
 
-    async* _stream({ prompt, fileData = null, model = Model.UNSPECIFIED, gem = null, chat = null, temporary = false, ss = null }) {
+    async* _stream({ prompt, fileData = null, model = Model.UNSPECIFIED, gem = null, chat = null, temporary = false, ss = null, deep_research = false }) {
         const _reqid = this._reqid;
         this._reqid += 100000;
-        const gemId = gem && typeof gem === 'object' ? gem.id : gem;
+        const gemId = gem instanceof Gem ? gem.id : gem;
+
+        const chatBackup = chat instanceof ChatSession ? {
+            metadata: [...chat.metadata],
+            cid: chat.cid,
+            rid: chat.rid,
+            rcid: chat.rcid,
+        } : null;
 
         const inner = new Array(69).fill(null);
         inner[0] = [prompt, 0, null, fileData, null, null, 0];
-        inner[2] = chat ? chat.metadata : ['', '', '', null, null, null, null, null, null, ''];
-        inner[7] = 1;
-        if (gemId) inner[19] = gemId;
+        inner[1] = [this.language || 'en'];
+        inner[2] = chat instanceof ChatSession ? chat.metadata : [...DEFAULT_METADATA];
+        if (deep_research) {
+            inner[3] = '!' + crypto.randomBytes(1950).toString('base64url');
+            inner[4] = crypto.randomUUID().replace(/-/g, '');
+        }
+        inner[6] = [1];
+        inner[STREAMING_FLAG_INDEX] = 1;
+        inner[10] = 1;
+        inner[11] = 0;
+        inner[17] = [[0]];
+        inner[18] = 0;
+        if (gemId) inner[GEM_FLAG_INDEX] = gemId;
+        inner[27] = 1;
+        inner[30] = [4];
+        inner[41] = [1];
         if (temporary) inner[TEMPORARY_CHAT_FLAG_INDEX] = 1;
-        inner[1] = ['en']; inner[6] = [0]; inner[10] = 1; inner[11] = 0;
-        inner[17] = [[0]]; inner[18] = 0; inner[27] = 1; inner[30] = [4];
-        inner[41] = [1]; inner[53] = 0; inner[61] = []; inner[68] = 1;
-        const uid = uuidv4();
+        if (deep_research) inner[49] = 1;
+        inner[53] = 0;
+        if (deep_research) {
+            inner[54] = [[[[[1]]]]];
+            inner[55] = [[1]];
+        }
+        inner[61] = [];
+        inner[68] = 2;
+
+        const uid = uuidv4().toUpperCase();
         inner[59] = uid;
 
-        const params = new URLSearchParams({ _reqid: String(_reqid), rt: 'c' });
+        const params = new URLSearchParams({
+            hl: this.language || 'en',
+            _reqid: String(_reqid),
+            rt: 'c',
+        });
         if (this.buildLabel) params.set('bl', this.buildLabel);
         if (this.sessionId) params.set('f.sid', this.sessionId);
 
-        const body = new URLSearchParams({ at: this.accessToken || '', 'f.req': JSON.stringify([null, JSON.stringify(inner)]) });
-
-        if (ss) {
-            if (!('original_cid' in ss)) ss.original_cid = chat ? chat.cid : null;
-            if (!('original_rcid' in ss)) ss.original_rcid = chat instanceof ChatSession ? chat.rcid : null;
-            if (!('had_response_data' in ss)) ss.had_response_data = false;
-
-            if (chat && chat.cid && (!ss.original_cid || ss.had_response_data)) {
-                const delays = [30000, 45000, 60000, 90000];
-                let allStale = true;
-                for (let i = 0; i < delays.length; i++) {
-                    console.warn(`Stream failed for cid=${chat.cid}. READ_CHAT attempt ${i + 1}/${delays.length}: waiting ${delays[i] / 1000}s...`);
-                    await sleep(delays[i]);
-                    try {
-                        const recovered = await this.fetchLatestChatResponse(chat.cid);
-                        if (recovered) {
-                            if (ss.original_cid && recovered.rcid && recovered.rcid === ss.original_rcid) continue;
-                            if (chat instanceof ChatSession) chat.metadata = recovered.metadata;
-                            yield recovered; return;
-                        }
-                        allStale = false;
-                    } catch (e) { allStale = false; console.warn(`READ_CHAT attempt ${i + 1} failed: ${e.message}`); }
-                }
-                if (allStale) {
-                    if (chat instanceof ChatSession) { chat.rid = ''; chat.rcid = ''; }
-                    ss.had_response_data = false;
-                    throw new APIError(`Stream failed for cid=${chat.cid}. All READ_CHAT stale. Retrying.`);
-                }
-                throw new GeminiError(`Stream failed for cid=${chat.cid}. Recovery returned no data.`);
-            }
-        }
-
-        const res = await axios.post(`${Endpoint.GENERATE}?${params}`, body.toString(), {
-            headers: { ...Headers.GEMINI, ...model.model_header, 'x-goog-ext-525005358-jspb': `["${uid}",1]`, 'Cookie': cookieStr(this.cookies) },
-            responseType: 'stream', timeout: this.timeout, validateStatus: null,
-            ...(this.proxy ? { proxy: parseProxy(this.proxy) } : {}),
+        const body = new URLSearchParams({
+            at: this.accessToken || '',
+            'f.req': JSON.stringify([null, JSON.stringify(inner)]),
         });
 
-        if (res.status !== 200) { await this.close(); throw new APIError(`Failed to generate contents. Status: ${res.status}`); }
+        let hasGeneratedText = false;
+        let sleepTime = 10000;
+
+        const res = await axios.post(
+            `${Endpoint.GENERATE}?${params}`,
+            body.toString(),
+            {
+                headers: {
+                    ...Headers.GEMINI,
+                    ...model.model_header,
+                    'x-goog-ext-525005358-jspb': `["${uid}",1]`,
+                    ...Headers.SAME_DOMAIN,
+                    'Cookie': cookieStr(this.cookies),
+                },
+                responseType: 'stream',
+                timeout: this.timeout,
+                validateStatus: null,
+                ...(this.proxy ? { proxy: parseProxy(this.proxy) } : {}),
+            },
+        );
+
+        if (res.status !== 200) {
+            await this.close();
+            throw new APIError(`Failed to generate contents. Status: ${res.status}`);
+        }
         Object.assign(this.cookies, parseCookies(res.headers));
 
-        const lTxt = ss ? ss.last_texts : {}, lThought = ss ? ss.last_thoughts : {};
+        const lTxt = ss ? ss.last_texts : {};
+        const lThought = ss ? ss.last_thoughts : {};
         let lastProg = Date.now();
-        let isThinking = false, isQueueing = false, hasCandidates = false, isCompleted = false, isFinalChunk = false;
+        let isThinking = false, isQueueing = false, hasCandidates = false;
+        let isCompleted = false, isFinalChunk = false;
+        let cid = chat instanceof ChatSession ? chat.cid : '';
+        let rid = chat instanceof ChatSession ? chat.rid : '';
         let buf = '';
 
-        const processParts = parts => {
+        const processParts = (parts) => {
             const outs = [];
             for (const part of parts) {
                 const ec = getNestedValue(part, [5, 2, 0, 1, 0]);
                 if (ec) {
                     switch (ec) {
-                        case ErrorCode.USAGE_LIMIT_EXCEEDED: throw new UsageLimitExceeded(`Usage limit exceeded for model '${model.model_name}'.`);
-                        case ErrorCode.MODEL_INCONSISTENT: throw new ModelInvalid('Model inconsistent with conversation history.');
-                        case ErrorCode.MODEL_HEADER_INVALID: throw new ModelInvalid(`Model '${model.model_name}' unavailable or request structure outdated.`);
-                        case ErrorCode.IP_TEMPORARILY_BLOCKED: throw new TemporarilyBlocked('IP temporarily blocked by Google.');
-                        case ErrorCode.TEMPORARY_ERROR_1013: throw new APIError('Temporary error (1013). Retrying...');
-                        default: throw new APIError(`Unknown API error code: ${ec}.`);
+                        case ErrorCode.USAGE_LIMIT_EXCEEDED:
+                            throw new UsageLimitExceeded(`Usage limit exceeded for model '${model.model_name}'.`);
+                        case ErrorCode.MODEL_INCONSISTENT:
+                            throw new ModelInvalid('Model inconsistent with conversation history.');
+                        case ErrorCode.MODEL_HEADER_INVALID:
+                            throw new ModelInvalid(`Model '${model.model_name}' unavailable or request structure outdated.`);
+                        case ErrorCode.IP_TEMPORARILY_BLOCKED:
+                            throw new TemporarilyBlocked('IP temporarily blocked by Google.');
+                        case ErrorCode.TEMPORARY_ERROR_1013:
+                            throw new APIError('Temporary error (1013). Retrying...');
+                        default:
+                            throw new APIError(`Unknown API error code: ${ec}.`);
                     }
                 }
 
-                if (JSON.stringify(part).includes('data_analysis_tool')) isThinking = true;
+                const toolName = JSON.stringify(part).includes('data_analysis_tool');
+                if (toolName) { isThinking = true; isQueueing = false; }
+
                 const status = getNestedValue(part, [5]);
-                if (Array.isArray(status) && status.length) isQueueing = true;
+                if (Array.isArray(status) && status.length) {
+                    if (!isThinking) isQueueing = true;
+                }
 
                 const innerStr = getNestedValue(part, [2]);
                 if (!innerStr) continue;
-                let pj; try { pj = JSON.parse(innerStr); } catch { continue; }
+                let pj;
+                try { pj = JSON.parse(innerStr); } catch { continue; }
 
                 const mData = getNestedValue(pj, [1]);
-                if (mData && chat instanceof ChatSession) { chat.metadata = mData; if (ss) ss.had_response_data = true; }
+                if (mData) {
+                    const newCid = getNestedValue(mData, [0]);
+                    const newRid = getNestedValue(mData, [1]);
+                    if (newCid) cid = newCid;
+                    if (newRid) rid = newRid;
+                    if (chat instanceof ChatSession) chat.metadata = mData;
+                }
 
                 const ctx = getNestedValue(pj, [25]);
                 if (typeof ctx === 'string') {
-                    isCompleted = true; isThinking = false; isQueueing = false;
-                    if (chat instanceof ChatSession) { const m = [...chat.metadata]; m[9] = ctx; chat.metadata = m; }
+                    isFinalChunk = true;
+                    isThinking = false;
+                    isQueueing = false;
+                    if (chat instanceof ChatSession) {
+                        const m = [...chat.metadata];
+                        m[9] = ctx;
+                        chat.metadata = m;
+                    }
                 }
 
                 const clist = getNestedValue(pj, [4], []);
@@ -303,49 +580,76 @@ class GeminiClient {
                 const outCands = [];
                 for (let i = 0; i < clist.length; i++) {
                     const cd = clist[i];
-                    const rcid = getNestedValue(cd, [0]); if (!rcid) continue;
+                    const rcid = getNestedValue(cd, [0]);
+                    if (!rcid) continue;
                     if (chat instanceof ChatSession) chat.rcid = rcid;
 
-                    let txt = getNestedValue(cd, [1, 0], '');
-                    if (/^http:\/\/googleusercontent\.com\/card_content\/\d+/.test(txt))
-                        txt = getNestedValue(cd, [22, 0]) || txt;
-                    txt = txt.replace(/http:\/\/googleusercontent\.com\/\w+\/\d+\n*/g, '');
+                    const [text, thoughts, webImgs, genImgs, genVideos, genMedia] = this._parseCandidate(cd, cid, rid, rcid);
 
-                    const thoughts = getNestedValue(cd, [37, 0, 0]) || '';
-                    const webImgs = [], genImgs = [];
-
-                    for (const wi of (getNestedValue(cd, [12, 1], []) || [])) {
-                        const url = getNestedValue(wi, [0, 0, 0]);
-                        if (url) webImgs.push(new WebImage({ url, title: getNestedValue(wi, [7, 0], ''), alt: getNestedValue(wi, [0, 4], ''), proxy: this.proxy }));
-                    }
-                    for (const gi of (getNestedValue(cd, [12, 7, 0], []) || [])) {
-                        const url = getNestedValue(gi, [0, 3, 3]);
-                        if (url) {
-                            const imgNum = getNestedValue(gi, [3, 6]);
-                            genImgs.push(new GeneratedImage({ url, title: imgNum ? `[Generated Image ${imgNum}]` : '[Generated Image]', alt: getNestedValue(gi, [3, 5, 0], ''), proxy: this.proxy, cookies: this.cookies }));
+                    let drPlan = null;
+                    if (deep_research) {
+                        const planData = extractDeepResearchPlan(cd, text);
+                        if (planData) {
+                            drPlan = new DeepResearchPlan({
+                                ...planData,
+                                cid: chat instanceof ChatSession ? chat.cid : null,
+                            });
                         }
                     }
 
-                    isFinalChunk = Array.isArray(getNestedValue(cd, [2])) || getNestedValue(cd, [8, 0], 1) === 2;
+                    const indicator = getNestedValue(cd, [8, 0]);
+                    isCompleted = indicator === 2;
+
+                    const lastSentText = lTxt[rcid] || lTxt[`idx_${i}`] || '';
+                    const [td, nft] = getDeltaByFpLen(text, lastSentText, isCompleted || indicator == null);
 
-                    const [td, nft] = getDeltaByFpLen(txt, lTxt[rcid] || lTxt[`idx_${i}`] || '', isFinalChunk);
                     let thdelta = '', nfth = '';
-                    if (thoughts) [thdelta, nfth] = getDeltaByFpLen(thoughts, lThought[rcid] || lThought[`idx_${i}`] || '', isFinalChunk);
+                    if (thoughts) {
+                        const lastSentThought = lThought[rcid] || lThought[`idx_${i}`] || '';
+                        [thdelta, nfth] = getDeltaByFpLen(thoughts, lastSentThought, isCompleted || indicator == null);
+                    }
+
+                    if (td || thdelta || webImgs.length || genImgs.length || genVideos.length || genMedia.length || drPlan) {
+                        hasCandidates = true;
+                    }
 
-                    if (td || thdelta || webImgs.length || genImgs.length) hasCandidates = true;
                     lTxt[rcid] = lTxt[`idx_${i}`] = nft;
                     lThought[rcid] = lThought[`idx_${i}`] = nfth;
 
-                    outCands.push(new Candidate({ rcid, text: txt, text_delta: td, thoughts: thoughts || null, thoughts_delta: thdelta, web_images: webImgs, generated_images: genImgs }));
+                    outCands.push(new Candidate({
+                        rcid,
+                        text,
+                        text_delta: td,
+                        thoughts: thoughts || null,
+                        thoughts_delta: thdelta,
+                        web_images: webImgs,
+                        generated_images: genImgs,
+                        generated_videos: genVideos,
+                        generated_media: genMedia,
+                        deep_research_plan: drPlan,
+                    }));
                 }
 
-                if (outCands.length) { isThinking = false; isQueueing = false; outs.push(new ModelOutput(getNestedValue(pj, [1], []), outCands)); }
+                if (outCands.length) {
+                    isThinking = false;
+                    isQueueing = false;
+                    outs.push(new ModelOutput(getNestedValue(pj, [1], []), outCands));
+                }
             }
             return outs;
         };
 
         const yielded = [];
+        let streamErr = null;
+
         await new Promise((resolve, reject) => {
+            const watchdog = setInterval(() => {
+                if (!isThinking && !isQueueing && (Date.now() - lastProg) > Math.min(this.timeout, this.watchdogTimeout)) {
+                    clearInterval(watchdog);
+                    reject(new APIError('Response stalled (zombie stream).'));
+                }
+            }, 1000);
+
             res.data.on('data', chunk => {
                 try {
                     buf += chunk.toString('utf8');
@@ -354,57 +658,269 @@ class GeminiClient {
                     buf = rem;
                     const outs = processParts(parts);
                     for (const o of outs) yielded.push(o);
-                    if (outs.length || isThinking || isQueueing) { lastProg = Date.now(); if (ss) ss.last_progress_time = lastProg; }
-                    else if (Date.now() - lastProg > Math.min(this.timeout, this.watchdogTimeout))
-                        reject(new APIError('Response stalled (zombie stream).'));
-                } catch (e) { reject(e); }
+                    if (outs.length || isThinking || isQueueing) lastProg = Date.now();
+                } catch (e) {
+                    clearInterval(watchdog);
+                    reject(e);
+                }
             });
+
             res.data.on('end', () => {
+                clearInterval(watchdog);
                 try {
-                    if (buf) { const [p] = parseResponseByFrame(buf); for (const o of processParts(p)) yielded.push(o); }
-                    if (!(isCompleted || isFinalChunk) || isThinking || isQueueing) reject(new APIError('Stream interrupted or truncated.'));
+                    if (buf) {
+                        const [p] = parseResponseByFrame(buf);
+                        for (const o of processParts(p)) yielded.push(o);
+                    }
+                    if (!isCompleted && !isFinalChunk) reject(new APIError('Stream interrupted or truncated.'));
                     else resolve();
                 } catch (e) { reject(e); }
             });
-            res.data.on('error', e => reject(new APIError(`Stream error: ${e.message}`)));
+
+            res.data.on('error', e => { clearInterval(watchdog); reject(new APIError(`Stream error: ${e.message}`)); });
         });
 
-        for (const o of yielded) yield o;
+        hasGeneratedText = yielded.length > 0;
+
+        if (!isCompleted && !isFinalChunk && cid) {
+            let pollStart = Date.now();
+            while (true) {
+                if ((Date.now() - pollStart) > this.timeout) {
+                    await this.close();
+                    if (hasGeneratedText) throw new GeminiError('Connection to Gemini lost. Recovery timed out.');
+                    else throw new APIError('read_chat polling timed out waiting for the model to finish.');
+                }
+                await this._sendBardActivity();
+                const recovered = await this.readChat(cid);
+                if (
+                    recovered && recovered.turns && recovered.turns.length > 0 &&
+                    recovered.turns[0].role === 'model'
+                ) {
+                    const recoveredOut = recovered.turns[0].model_output;
+                    if (recoveredOut && recoveredOut.candidates && (recoveredOut.text || recoveredOut.thoughts)) {
+                        const recRcid = recoveredOut.rcid;
+                        const prevRcid = chatBackup ? chatBackup.rcid : '';
+                        if (recRcid !== prevRcid) {
+                            if (chat instanceof ChatSession) {
+                                recoveredOut.metadata = chat.metadata;
+                                chat.rcid = recRcid;
+                            }
+                            yield recoveredOut;
+                            return;
+                        }
+                    }
+                }
+                await sleep(sleepTime);
+            }
+        }
+
+        for (const o of yielded) {
+            hasGeneratedText = true;
+            yield o;
+        }
+    }
+
+    _parseCandidate(candidateData, cid, rid, rcid) {
+        let text = getNestedValue(candidateData, [1, 0], '');
+        if (CARD_CONTENT_RE.test(text)) {
+            text = getNestedValue(candidateData, [22, 0]) || text;
+        }
+        ARTIFACTS_RE.lastIndex = 0;
+        text = text.replace(ARTIFACTS_RE, '');
+
+        const thoughts = getNestedValue(candidateData, [37, 0, 0]) || '';
+
+        const webImages = [];
+        for (const [imgIdx, wi] of (getNestedValue(candidateData, [12, 1], []) || []).entries()) {
+            const url = getNestedValue(wi, [0, 0, 0]);
+            if (url) {
+                webImages.push(new WebImage({
+                    url,
+                    title: `[Image ${imgIdx + 1}]`,
+                    alt: getNestedValue(wi, [0, 4], ''),
+                    proxy: this.proxy,
+                }));
+            }
+        }
+
+        const generatedImages = [];
+        const genImgSources = [
+            ...(getNestedValue(candidateData, [12, 7, 0], []) || []),
+            ...(getNestedValue(candidateData, [12, 0, '8', 0], []) || []),
+        ];
+        for (const [imgIdx, gi] of genImgSources.entries()) {
+            const url = getNestedValue(gi, [0, 3, 3]);
+            if (url) {
+                let imageId = getNestedValue(gi, [1, 0]);
+                if (!imageId) imageId = `http://googleusercontent.com/image_generation_content/${imgIdx}`;
+                generatedImages.push(new GeneratedImage({
+                    url,
+                    title: `[Generated Image ${imgIdx}]`,
+                    alt: getNestedValue(gi, [0, 3, 2], ''),
+                    proxy: this.proxy,
+                    client_ref: this,
+                    cid,
+                    rid,
+                    rcid,
+                    image_id: imageId,
+                }));
+            }
+        }
+
+        const generatedVideos = [];
+        const videoInfo = getNestedValue(candidateData, [12, 59, 0, 0, 0], []);
+        if (videoInfo) {
+            const urls = getNestedValue(videoInfo, [0, 7], []);
+            if (Array.isArray(urls) && urls.length >= 2) {
+                generatedVideos.push(new GeneratedVideo({
+                    url: urls[1],
+                    thumbnail: urls[0],
+                    cid,
+                    rid,
+                    rcid,
+                    client_ref: this,
+                    proxy: this.proxy,
+                }));
+            }
+        }
+
+        const generatedMedia = [];
+        const mediaData = getNestedValue(candidateData, [12, 86], []);
+        if (mediaData) {
+            let mp3Url = '', mp3Thumb = '';
+            const mp3List = getNestedValue(mediaData, [0, 1, 7], []);
+            if (Array.isArray(mp3List) && mp3List.length >= 2) {
+                mp3Thumb = mp3List[0];
+                mp3Url = mp3List[1];
+            }
+            let mp4Url = '', mp4Thumb = '';
+            const mp4List = getNestedValue(mediaData, [1, 1, 7], []);
+            if (Array.isArray(mp4List) && mp4List.length >= 2) {
+                mp4Thumb = mp4List[0];
+                mp4Url = mp4List[1];
+            }
+            if (mp3Url || mp4Url) {
+                generatedMedia.push(new GeneratedMedia({
+                    url: mp4Url,
+                    thumbnail: mp4Thumb,
+                    mp3_url: mp3Url,
+                    mp3_thumbnail: mp3Thumb,
+                    cid,
+                    rid,
+                    rcid,
+                    client_ref: this,
+                    proxy: this.proxy,
+                }));
+            }
+        }
+
+        return [text, thoughts, webImages, generatedImages, generatedVideos, generatedMedia];
+    }
+
+    async _getFullSizeImage(cid, rid, rcid, imageId) {
+        try {
+            const payload = [
+                [
+                    [null, null, null, [null, null, null, null, null, '']],
+                    [imageId, 0],
+                    null,
+                    [19, ''],
+                    null, null, null, null, null, '',
+                ],
+                [rid, rcid, cid, null, ''],
+                1, 0, 1,
+            ];
+
+            const response = await this._batchExecute([
+                new RPCData({
+                    rpcid: GRPC.GET_FULL_SIZE_IMAGE,
+                    payload: JSON.stringify(payload),
+                }),
+            ]);
+
+            const responseData = extractJsonFromResponse(response.data);
+            const bodyStr = getNestedValue(responseData, [0, 2], '[]');
+            return getNestedValue(JSON.parse(bodyStr), [0]);
+        } catch {
+            return null;
+        }
     }
 
-    startChat(opts = {}) { return new ChatSession({ geminiclient: this, ...opts }); }
+    startChat(opts = {}) {
+        return new ChatSession({ geminiclient: this, ...opts });
+    }
 }
 
-applyMixins(GeminiClient, ChatMixin, GemMixin);
+applyMixins(GeminiClient, ChatMixin, GemMixin, ResearchMixin);
 
 class ChatSession {
-    constructor({ geminiclient, metadata = null, cid = null, rid = null, rcid = null, model = null, gem = null } = {}) {
-        this._metadata = ['', '', '', null, null, null, null, null, null, ''];
+    constructor({
+        geminiclient,
+        metadata = null,
+        cid = '',
+        rid = '',
+        rcid = '',
+        model = Model.UNSPECIFIED,
+        gem = null,
+    } = {}) {
+        this._metadata = [...DEFAULT_METADATA];
         this.geminiclient = geminiclient;
         this.lastOutput = null;
-        this.model = ChatSession._resolveModel(model);
+        this.model = this._resolveModel(model);
         this.gem = gem;
+
         if (metadata) this.metadata = metadata;
         if (cid) this.cid = cid;
         if (rid) this.rid = rid;
         if (rcid) this.rcid = rcid;
     }
 
+    _resolveModel(model) {
+        if (!model || model === Model.UNSPECIFIED) return Model.UNSPECIFIED;
+        if (typeof model === 'string') return Model.fromName(model);
+        if (typeof model === 'object' && model.model_header === undefined) return Model.fromDict(model);
+        return model;
+    }
+
     get metadata() { return this._metadata; }
     set metadata(v) {
         if (!Array.isArray(v)) return;
-        for (let i = 0; i < v.length && i < 10; i++) if (v[i] != null) this._metadata[i] = v[i];
+        for (let i = 0; i < v.length && i < 10; i++) {
+            if (v[i] != null) this._metadata[i] = v[i];
+        }
     }
-    get cid() { return this._metadata[0]; } set cid(v) { this._metadata[0] = v; }
-    get rid() { return this._metadata[1]; } set rid(v) { this._metadata[1] = v; }
-    get rcid() { return this._metadata[2]; } set rcid(v) { this._metadata[2] = v; }
 
-    async sendMessage({ prompt, files = null, temporary = false } = {}) {
-        return this.geminiclient.generateContent({ prompt, files, model: this.model, gem: this.gem, chat: this, temporary });
+    get cid() { return this._metadata[0]; }
+    set cid(v) { this._metadata[0] = v; }
+
+    get rid() { return this._metadata[1]; }
+    set rid(v) { this._metadata[1] = v; }
+
+    get rcid() { return this._metadata[2]; }
+    set rcid(v) { this._metadata[2] = v; }
+
+    async sendMessage({ prompt, files = null, temporary = false, deep_research = false } = {}) {
+        return this.geminiclient.generateContent({
+            prompt,
+            files,
+            model: this.model,
+            gem: this.gem,
+            chat: this,
+            temporary,
+            deep_research,
+        });
     }
 
-    async* sendMessageStream({ prompt, files = null, temporary = false } = {}) {
-        for await (const out of this.geminiclient.generateContentStream({ prompt, files, model: this.model, gem: this.gem, chat: this, temporary })) yield out;
+    async* sendMessageStream({ prompt, files = null, temporary = false, deep_research = false } = {}) {
+        for await (const out of this.geminiclient.generateContentStream({
+            prompt,
+            files,
+            model: this.model,
+            gem: this.gem,
+            chat: this,
+            temporary,
+            deep_research,
+        })) yield out;
     }
 
     chooseCandidate(index) {
@@ -415,14 +931,14 @@ class ChatSession {
         return this.lastOutput;
     }
 
-    static _resolveModel(model) {
-        if (!model) return Model.UNSPECIFIED;
-        if (typeof model === 'string') return Model.fromName(model);
-        if (typeof model === 'object' && !model.model_name) return Model.fromDict(model);
-        return model;
+    async readHistory(limit = 10) {
+        if (!this.cid) return null;
+        return this.geminiclient.readChat(this.cid, limit);
     }
 
-    toString() { return `ChatSession(cid='${this.cid}', rid='${this.rid}', rcid='${this.rcid}')`; }
+    toString() {
+        return `ChatSession(cid='${this.cid}', rid='${this.rid}', rcid='${this.rcid}')`;
+    }
 }
 
-module.exports = { GeminiClient, ChatSession };
+module.exports = { GeminiClient, ChatSession };