gemini-reverse 1.0.1 → 1.0.3

package/components/chatMixin.js

@@ -4,101 +4,160 @@ const { GRPC } = require('../constants');
 const { RPCData } = require('../types/grpc');
 const { Candidate } = require('../types/candidate');
 const { ModelOutput } = require('../types/modeloutput');
-const { ConversationTurn } = require('../types/conversation');
+const { ChatTurn, ChatHistory } = require('../types/chathistory');
+const { ChatInfo } = require('../types/chatinfo');
 const { extractJsonFromResponse, getNestedValue } = require('../utils/parsing');
 
 class ChatMixin {
-    async _fetchChatTurns(cid, maxTurns = 10) {
-        const response = await this._batchExecute([
-            new RPCData({ rpcid: GRPC.READ_CHAT, payload: JSON.stringify([cid, maxTurns, null, 1, [0], [4], null, 1]) }),
-        ]);
+    constructor() {
+        this._recentChats = null;
+    }
 
-        const responseJson = extractJsonFromResponse(response.data);
+    async _fetchRecentChats(recent = 13) {
+        const fetchBatch = async (payload) => {
+            return this._batchExecute([
+                new RPCData({ rpcid: GRPC.LIST_CHATS, payload: JSON.stringify([recent, null, payload]) }),
+            ]);
+        };
+
+        const [resp1, resp2] = await Promise.all([
+            fetchBatch([1, null, 1]),
+            fetchBatch([0, null, 1]),
+        ]);
 
-        for (const part of responseJson) {
-            const bodyStr = getNestedValue(part, [2]);
-            if (!bodyStr) continue;
-            const body = JSON.parse(bodyStr);
-            const turns = getNestedValue(body, [0]);
-            if (!turns || !Array.isArray(turns)) continue;
-            return turns;
+        const recentChats = [];
+        const seenCids = new Set();
+
+        for (const response of [resp1, resp2]) {
+            const chatsJson = extractJsonFromResponse(response.data);
+            for (const part of chatsJson) {
+                const bodyStr = getNestedValue(part, [2]);
+                if (!bodyStr) continue;
+                let body;
+                try { body = JSON.parse(bodyStr); } catch { continue; }
+                const chatList = getNestedValue(body, [2]);
+                if (!Array.isArray(chatList)) continue;
+                for (const chatData of chatList) {
+                    if (!Array.isArray(chatData) || chatData.length < 2) continue;
+                    const cid = getNestedValue(chatData, [0], '');
+                    const title = getNestedValue(chatData, [1], '');
+                    const is_pinned = Boolean(getNestedValue(chatData, [2]));
+                    const tsData = getNestedValue(chatData, [5]);
+                    let timestamp = 0;
+                    if (Array.isArray(tsData) && tsData.length >= 2) {
+                        timestamp = Number(tsData[0]) + Number(tsData[1]) / 1e9;
+                    }
+                    if (cid && !seenCids.has(cid)) {
+                        seenCids.add(cid);
+                        recentChats.push(new ChatInfo({ cid, title, is_pinned, timestamp }));
+                    }
+                }
+                break;
+            }
         }
 
-        console.warn(`_fetchChatTurns(${cid}) found no turns`);
-        return null;
+        this._recentChats = recentChats;
     }
 
-    async fetchLatestChatResponse(cid) {
-        try {
-            const turns = await this._fetchChatTurns(cid, 10);
-            if (!turns) return null;
-
-            const convTurn = turns[turns.length - 1];
-            if (!convTurn) return null;
-
-            const candidatesList = getNestedValue(convTurn, [3, 0]);
-            if (!candidatesList) return null;
-
-            const candidateData = getNestedValue(candidatesList, [0]);
-            if (!candidateData) return null;
+    listChats() {
+        return this._recentChats;
+    }
 
-            const rcid = getNestedValue(candidateData, [0], '');
-            const text = getNestedValue(candidateData, [1, 0], '');
-            if (!text) return null;
+    async readChat(cid, limit = 10) {
+        try {
+            const response = await this._batchExecute([
+                new RPCData({
+                    rpcid: GRPC.READ_CHAT,
+                    payload: JSON.stringify([cid, limit, null, 1, [1], [4], null, 1]),
+                }),
+            ]);
+
+            const responseJson = extractJsonFromResponse(response.data);
+
+            for (const part of responseJson) {
+                const bodyStr = getNestedValue(part, [2]);
+                if (!bodyStr) continue;
+                let body;
+                try { body = JSON.parse(bodyStr); } catch { continue; }
+                const turnsData = getNestedValue(body, [0]);
+                if (!turnsData) continue;
+
+                const chatTurns = [];
+                for (const convTurn of turnsData) {
+                    const rid = getNestedValue(convTurn, [0, 1], '');
+
+                    const candidatesList = getNestedValue(convTurn, [3, 0]);
+                    if (candidatesList) {
+                        const outputCandidates = [];
+                        for (const candidateData of candidatesList) {
+                            const completionStatus = getNestedValue(candidateData, [8, 0]);
+                            const hasProgressSignal = getNestedValue(candidateData, [12, 6, 0]) != null;
+
+                            if (completionStatus !== 2 && hasProgressSignal) {
+                                return null;
+                            }
+
+                            const rcid = getNestedValue(candidateData, [0]);
+                            if (!rcid) continue;
+
+                            const parsed = this._parseCandidate(candidateData, cid, rid, rcid);
+                            const [text, thoughts, webImages, genImages, genVideos, genMedia] = parsed;
+
+                            outputCandidates.push(new Candidate({
+                                rcid,
+                                text,
+                                text_delta: text,
+                                thoughts,
+                                thoughts_delta: thoughts,
+                                web_images: webImages,
+                                generated_images: genImages,
+                                generated_videos: genVideos,
+                                generated_media: genMedia,
+                            }));
+                        }
+                        if (outputCandidates.length) {
+                            const modelOutput = new ModelOutput([cid, rid], outputCandidates);
+                            chatTurns.push(new ChatTurn({ role: 'model', text: modelOutput.text, model_output: modelOutput }));
+                        }
+                    }
+
+                    const userText = getNestedValue(convTurn, [2, 0, 0], '');
+                    if (userText) {
+                        chatTurns.push(new ChatTurn({ role: 'user', text: userText }));
+                    }
+                }
 
-            const turnMeta = getNestedValue(convTurn, [0]);
-            const rid = Array.isArray(turnMeta) && turnMeta.length >= 2 && typeof turnMeta[1] === 'string' ? turnMeta[1] : '';
-            const metadata = rid ? [cid, rid] : [cid];
+                return new ChatHistory({ cid, turns: chatTurns });
+            }
 
-            return new ModelOutput(metadata, [new Candidate({ rcid, text })]);
-        } catch (e) {
-            console.warn(`fetchLatestChatResponse(${cid}) error: ${e.message}`);
+            return null;
+        } catch {
             return null;
         }
     }
 
-    async readChat(cid, maxTurns = 100) {
+    async fetchLatestChatResponse(cid) {
         try {
-            const turns = await this._fetchChatTurns(cid, maxTurns);
-            if (!turns) return [];
-
-            const result = [];
-            for (const turn of turns) {
-                if (!Array.isArray(turn) || turn.length < 4) continue;
-
-                const turnMeta = getNestedValue(turn, [0]);
-                const rid = Array.isArray(turnMeta) ? (getNestedValue(turnMeta, [1], '') || '') : '';
-                const userPrompt = getNestedValue(turn, [2, 0, 0], '');
-                const candidateData = getNestedValue(turn, [3, 0, 0]);
-                if (!candidateData) continue;
-
-                const rcid = getNestedValue(candidateData, [0], '');
-                const text = getNestedValue(candidateData, [1, 0], '');
-                if (!text) continue;
-
-                const thoughts = getNestedValue(candidateData, [37, 0, 0]) || null;
-                const tsData = getNestedValue(turn, [4]);
-                let timestamp = null;
-                if (Array.isArray(tsData) && tsData.length && typeof tsData[0] === 'number') {
-                    try { timestamp = new Date(tsData[0] * 1000); } catch {}
-                }
-
-                result.push(new ConversationTurn({ rid, user_prompt: userPrompt, assistant_response: text, rcid, thoughts, timestamp }));
+            const history = await this.readChat(cid, 5);
+            if (!history || !history.turns || !history.turns.length) return null;
+            for (const turn of history.turns) {
+                if (turn.role === 'model' && turn.model_output) return turn.model_output;
             }
-
-            result.reverse();
-            return result;
+            return null;
         } catch (e) {
-            console.warn(`readChat(${cid}) error: ${e.message}`);
-            return [];
+            console.warn(`fetchLatestChatResponse(${cid}) error: ${e.message}`);
+            return null;
         }
     }
 
     async deleteChat(cid) {
         await this._batchExecute([
-            new RPCData({ rpcid: GRPC.DELETE_CHAT, payload: JSON.stringify([cid]) }),
+            new RPCData({ rpcid: GRPC.DELETE_CHAT_1, payload: JSON.stringify([cid]) }),
+        ]);
+        await this._batchExecute([
+            new RPCData({ rpcid: GRPC.DELETE_CHAT_2, payload: JSON.stringify([cid, [1, null, 0, 1]]) }),
         ]);
     }
 }
 
-module.exports = { ChatMixin };
+module.exports = { ChatMixin };

package/components/index.js

@@ -2,5 +2,6 @@
 
 const { ChatMixin } = require('./chatMixin');
 const { GemMixin } = require('./gemMixin');
+const { ResearchMixin } = require('./researchMixin');
 
-module.exports = { ChatMixin, GemMixin };
+module.exports = { ChatMixin, GemMixin, ResearchMixin };

package/components/researchMixin.js

@@ -0,0 +1,202 @@
+'use strict';
+
+const { GRPC } = require('../constants');
+const { APIError, GeminiError, ModelInvalid, TemporarilyBlocked, TimeoutError, UsageLimitExceeded } = require('../exceptions');
+const { DeepResearchPlan, DeepResearchStatus } = require('../types/research');
+const { DeepResearchResult } = require('../types/researchresult');
+const { RPCData } = require('../types/grpc');
+const { extractJsonFromResponse, getNestedValue } = require('../utils/parsing');
+const { extractDeepResearchStatusPayload } = require('../utils/research');
+
+function sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
+
+class ResearchMixin {
+    async inspectAccountStatus() {
+        const probes = [
+            ['activity', GRPC.BARD_SETTINGS, '[[["bard_activity_enabled"]]]'],
+            ['bootstrap', GRPC.DEEP_RESEARCH_BOOTSTRAP, '["en",null,null,null,4,null,null,[2,4,7,15],null,[[5]]]'],
+            ['model_state', GRPC.DEEP_RESEARCH_MODEL_STATE, '[[[1,4],[6,6],[1,15]]]'],
+            ['quota', GRPC.DEEP_RESEARCH_MODEL_STATE, '[[[1,11],[2,11],[6,11]]]'],
+            ['caps', GRPC.DEEP_RESEARCH_CAPS, '[]'],
+        ];
+
+        const result = { source_path: '/app', rpc: {} };
+
+        for (const [probeName, rpcid, payload] of probes) {
+            try {
+                const response = await this._batchExecute([new RPCData({ rpcid, payload })], 2, false);
+                const parsed = [];
+                let rejectCode = null;
+                const parts = extractJsonFromResponse(response.data);
+                for (const part of parts) {
+                    if (getNestedValue(part, [0]) !== 'wrb.fr') continue;
+                    if (getNestedValue(part, [1]) !== rpcid) continue;
+                    const code = getNestedValue(part, [5, 0]);
+                    if (typeof code === 'number') rejectCode = code;
+                    const body = getNestedValue(part, [2]);
+                    if (typeof body === 'string') {
+                        try { parsed.push(JSON.parse(body)); } catch { parsed.push(body); }
+                    } else if (body != null) {
+                        parsed.push(body);
+                    }
+                }
+                result.rpc[probeName] = {
+                    rpcid,
+                    ok: true,
+                    status_code: response.status,
+                    parsed,
+                    reject_code: rejectCode,
+                };
+            } catch (e) {
+                result.rpc[probeName] = { rpcid, ok: false, error: `${e.constructor.name}: ${e.message}` };
+            }
+        }
+
+        const drProbes = ['bootstrap', 'model_state', 'caps'];
+        const drAvailable = drProbes.every(p => {
+            const probe = result.rpc[p];
+            return probe && probe.ok && probe.reject_code == null;
+        });
+
+        const rejected = Object.entries(result.rpc)
+            .filter(([, v]) => v && v.reject_code === 7)
+            .map(([k]) => k);
+
+        result.summary = { deep_research_feature_present: drAvailable, rejected_probes: rejected };
+        return result;
+    }
+
+    async _assertDeepResearchCapable() {
+        const snapshot = await this.inspectAccountStatus();
+        const summary = snapshot.summary || {};
+        if (!summary.deep_research_feature_present) {
+            const rejected = summary.rejected_probes || [];
+            const rpc = snapshot.rpc || {};
+            const failed = Object.entries(rpc)
+                .filter(([, v]) => v && !v.ok)
+                .map(([k]) => k);
+            throw new GeminiError(`Current account/session appears not eligible for deep research. Rejected: ${JSON.stringify(rejected)}, Failed: ${JSON.stringify(failed)}`);
+        }
+    }
+
+    async _deepResearchPreflight() {
+        const bestEffort = async (payloads) => {
+            try { await this._batchExecute(payloads, 2, false); } catch (e) {
+                console.warn(`Skipping non-critical preflight RPC: ${e.message}`);
+            }
+        };
+
+        await bestEffort([new RPCData({ rpcid: GRPC.BARD_SETTINGS, payload: '[[["bard_activity_enabled"]]]' })]);
+        await bestEffort([new RPCData({ rpcid: GRPC.DEEP_RESEARCH_BOOTSTRAP, payload: '["en",null,null,null,4,null,null,[2,4,7,15],null,[[5]]]' })]);
+    }
+
+    async _collectResearchOutput(chat, prompt) {
+        let recoverableError = null;
+        try {
+            const output = await chat.sendMessage({ prompt, deep_research: true });
+            const preview = (output.text || '').trim();
+            if (output.deep_research_plan || preview) {
+                chat.lastOutput = output;
+                return output;
+            }
+        } catch (e) {
+            if (e instanceof UsageLimitExceeded || e instanceof TimeoutError || e instanceof ModelInvalid || e instanceof TemporarilyBlocked) throw e;
+            if (e instanceof GeminiError || e instanceof APIError) recoverableError = e;
+            else throw e;
+        }
+
+        if (chat.cid) {
+            const fallback = await this.fetchLatestChatResponse(chat.cid);
+            if (fallback) {
+                chat.lastOutput = fallback;
+                return fallback;
+            }
+        }
+
+        if (recoverableError) throw recoverableError;
+        throw new GeminiError(`Gemini returned no usable output for deep research. chat.cid=${chat.cid}`);
+    }
+
+    async createDeepResearchPlan(prompt, chat = null, model = null) {
+        if (!chat) chat = this.startChat(model ? { model } : {});
+        await this._assertDeepResearchCapable();
+        await this._deepResearchPreflight();
+        const output = await this._collectResearchOutput(chat, prompt);
+        const plan = output.deep_research_plan;
+        if (!plan) {
+            const preview = (output.text || '').slice(0, 1200);
+            throw new GeminiError(`Gemini did not return a deep research plan. Preview: ${preview}`);
+        }
+        plan.metadata = [...chat.metadata];
+        plan.cid = chat.cid || plan.cid;
+        if (!plan.confirm_prompt) plan.confirm_prompt = 'Start research';
+        if (!plan.response_text) plan.response_text = output.text;
+        return plan;
+    }
+
+    async startDeepResearch(plan, chat = null, confirmPrompt = null) {
+        if (!chat) chat = this.startChat({ metadata: [...plan.metadata], cid: plan.cid });
+        await this._deepResearchPreflight();
+        const prompt = confirmPrompt || plan.confirm_prompt || 'Start research';
+        return await this._collectResearchOutput(chat, prompt);
+    }
+
+    async getDeepResearchStatus(researchId) {
+        const response = await this._batchExecute([
+            new RPCData({ rpcid: GRPC.DEEP_RESEARCH_STATUS, payload: JSON.stringify([researchId]) }),
+        ]);
+        const responseJson = extractJsonFromResponse(response.data);
+        for (const part of responseJson) {
+            const bodyStr = getNestedValue(part, [2]);
+            if (!bodyStr) continue;
+            let body;
+            try { body = JSON.parse(bodyStr); } catch { continue; }
+            const parsed = extractDeepResearchStatusPayload(body);
+            if (parsed) return new DeepResearchStatus(parsed);
+        }
+        return null;
+    }
+
+    async waitForDeepResearch(plan, pollInterval = 10000, timeout = 600000, onStatus = null) {
+        if (!plan.research_id) {
+            throw new GeminiError('Cannot poll deep research status: plan.research_id is missing.');
+        }
+
+        const start = Date.now();
+        const statuses = [];
+        const chat = this.startChat({ metadata: [...plan.metadata], cid: plan.cid });
+
+        while ((Date.now() - start) < timeout) {
+            let status = null;
+            if (plan.research_id) {
+                status = await this.getDeepResearchStatus(plan.research_id);
+            }
+            if (status) {
+                statuses.push(status);
+                if (onStatus) onStatus(status);
+                if (status.done) break;
+            }
+            await sleep(pollInterval);
+        }
+
+        if (!statuses.length || !statuses[statuses.length - 1].done) {
+            console.warn(`Deep research [${plan.research_id}] timed out after ${timeout}ms with ${statuses.length} status updates`);
+        }
+
+        let finalOutput = null;
+        if (chat.cid) finalOutput = await this.fetchLatestChatResponse(chat.cid);
+
+        const done = statuses.length > 0 && statuses[statuses.length - 1].done;
+        return new DeepResearchResult({ plan, statuses, final_output: finalOutput, done });
+    }
+
+    async deepResearch(prompt, pollInterval = 10000, timeout = 600000, onStatus = null) {
+        const plan = await this.createDeepResearchPlan(prompt);
+        const startOutput = await this.startDeepResearch(plan);
+        const result = await this.waitForDeepResearch(plan, pollInterval, timeout, onStatus);
+        result.start_output = startOutput;
+        return result;
+    }
+}
+
+module.exports = { ResearchMixin };