gemini-reverse 1.0.0

package/constants.js

@@ -0,0 +1,94 @@
+'use strict';
+
+const TEMPORARY_CHAT_FLAG_INDEX = 45;
+
+const Endpoint = {
+    GOOGLE: 'https://www.google.com',
+    INIT: 'https://gemini.google.com/app',
+    GENERATE: 'https://gemini.google.com/_/BardChatUi/data/assistant.lamda.BardFrontendService/StreamGenerate',
+    ROTATE_COOKIES: 'https://accounts.google.com/RotateCookies',
+    UPLOAD: 'https://content-push.googleapis.com/upload',
+    BATCH_EXEC: 'https://gemini.google.com/_/BardChatUi/data/batchexecute',
+};
+
+const GRPC = {
+    LIST_CHATS: 'MaZiqc',
+    READ_CHAT: 'hNvQHb',
+    DELETE_CHAT: 'GzXR5e',
+    LIST_GEMS: 'CNgdBe',
+    CREATE_GEM: 'oMH3Zd',
+    UPDATE_GEM: 'kHv0Vd',
+    DELETE_GEM: 'UXcSJb',
+    BARD_ACTIVITY: 'ESY5D',
+};
+
+const Headers = {
+    GEMINI: {
+        'Content-Type': 'application/x-www-form-urlencoded;charset=utf-8',
+        'Host': 'gemini.google.com',
+        'Origin': 'https://gemini.google.com',
+        'Referer': 'https://gemini.google.com/',
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36',
+        'X-Same-Domain': '1',
+    },
+    ROTATE_COOKIES: {
+        'Content-Type': 'application/json',
+    },
+    UPLOAD: {
+        'Push-ID': 'feeds/mcudyrk2a4khkz',
+    },
+};
+
+const Model = {
+    UNSPECIFIED: { model_name: 'unspecified', model_header: {}, advanced_only: false },
+    G_3_1_PRO: {
+        model_name: 'gemini-3.1-pro',
+        model_header: {
+            'x-goog-ext-525001261-jspb': '[1,null,null,null,"e6fa609c3fa255c0",null,null,0,[4],null,null,2]',
+            'x-goog-ext-73010989-jspb': '[0]',
+            'x-goog-ext-73010990-jspb': '[0]',
+        },
+        advanced_only: false,
+    },
+    G_3_0_FLASH: {
+        model_name: 'gemini-3.0-flash',
+        model_header: {
+            'x-goog-ext-525001261-jspb': '[1,null,null,null,"fbb127bbb056c959",null,null,0,[4],null,null,1]',
+            'x-goog-ext-73010989-jspb': '[0]',
+            'x-goog-ext-73010990-jspb': '[0]',
+        },
+        advanced_only: false,
+    },
+    G_3_0_FLASH_THINKING: {
+        model_name: 'gemini-3.0-flash-thinking',
+        model_header: {
+            'x-goog-ext-525001261-jspb': '[1,null,null,null,"5bf011840784117a",null,null,0,[4],null,null,1]',
+            'x-goog-ext-73010989-jspb': '[0]',
+            'x-goog-ext-73010990-jspb': '[0]',
+        },
+        advanced_only: false,
+    },
+    fromName(name) {
+        const legacy = { 'gemini-3.0-pro': 'gemini-3.1-pro' };
+        const resolved = legacy[name] || name;
+        for (const k of ['UNSPECIFIED', 'G_3_1_PRO', 'G_3_0_FLASH', 'G_3_0_FLASH_THINKING']) {
+            if (Model[k].model_name === resolved) return Model[k];
+        }
+        throw new Error(`Unknown model name: ${name}. Available: ${['UNSPECIFIED', 'G_3_1_PRO', 'G_3_0_FLASH', 'G_3_0_FLASH_THINKING'].map(k => Model[k].model_name).join(', ')}`);
+    },
+    fromDict(d) {
+        if (!d.model_name || !d.model_header || typeof d.model_header !== 'object')
+            throw new Error('model_name and model_header (object) required');
+        return { model_name: d.model_name, model_header: d.model_header, advanced_only: false };
+    },
+};
+
+const ErrorCode = {
+    TEMPORARY_ERROR_1013: 1013,
+    USAGE_LIMIT_EXCEEDED: 1037,
+    MODEL_INCONSISTENT: 1050,
+    MODEL_HEADER_INVALID: 1052,
+    IP_TEMPORARILY_BLOCKED: 1060,
+};
+
+module.exports = { TEMPORARY_CHAT_FLAG_INDEX, Endpoint, GRPC, Headers, Model, ErrorCode };

package/exceptions.js

@@ -0,0 +1,35 @@
+'use strict';
+
+class AuthError extends Error {
+    constructor(m) { super(m); this.name = 'AuthError'; }
+}
+
+class APIError extends Error {
+    constructor(m) { super(m); this.name = 'APIError'; }
+}
+
+class ImageGenerationError extends APIError {
+    constructor(m) { super(m); this.name = 'ImageGenerationError'; }
+}
+
+class GeminiError extends Error {
+    constructor(m) { super(m); this.name = 'GeminiError'; }
+}
+
+class TimeoutError extends GeminiError {
+    constructor(m) { super(m); this.name = 'TimeoutError'; }
+}
+
+class UsageLimitExceeded extends GeminiError {
+    constructor(m) { super(m); this.name = 'UsageLimitExceeded'; }
+}
+
+class ModelInvalid extends GeminiError {
+    constructor(m) { super(m); this.name = 'ModelInvalid'; }
+}
+
+class TemporarilyBlocked extends GeminiError {
+    constructor(m) { super(m); this.name = 'TemporarilyBlocked'; }
+}
+
+module.exports = { AuthError, APIError, ImageGenerationError, GeminiError, TimeoutError, UsageLimitExceeded, ModelInvalid, TemporarilyBlocked };

package/index.d.ts

@@ -0,0 +1,329 @@
+export interface ModelHeader {
+    'x-goog-ext-525001261-jspb'?: string;
+    'x-goog-ext-73010989-jspb'?: string;
+    'x-goog-ext-73010990-jspb'?: string;
+    [key: string]: string | undefined;
+}
+
+export interface ModelDef {
+    model_name: string;
+    model_header: ModelHeader;
+    advanced_only: boolean;
+}
+
+export interface ModelDict {
+    model_name: string;
+    model_header: ModelHeader;
+}
+
+export type ModelInput = string | ModelDef | ModelDict | null;
+
+export declare const Model: {
+    readonly UNSPECIFIED: ModelDef;
+    readonly G_3_1_PRO: ModelDef;
+    readonly G_3_0_FLASH: ModelDef;
+    readonly G_3_0_FLASH_THINKING: ModelDef;
+    fromName(name: string): ModelDef;
+    fromDict(d: ModelDict): ModelDef;
+};
+
+export declare const GRPC: {
+    readonly LIST_CHATS: string;
+    readonly READ_CHAT: string;
+    readonly DELETE_CHAT: string;
+    readonly LIST_GEMS: string;
+    readonly CREATE_GEM: string;
+    readonly UPDATE_GEM: string;
+    readonly DELETE_GEM: string;
+    readonly BARD_ACTIVITY: string;
+};
+
+export declare const Endpoint: {
+    readonly GOOGLE: string;
+    readonly INIT: string;
+    readonly GENERATE: string;
+    readonly ROTATE_COOKIES: string;
+    readonly UPLOAD: string;
+    readonly BATCH_EXEC: string;
+};
+
+export declare const Headers: {
+    readonly GEMINI: Record<string, string>;
+    readonly ROTATE_COOKIES: Record<string, string>;
+    readonly UPLOAD: Record<string, string>;
+};
+
+export declare const ErrorCode: {
+    readonly TEMPORARY_ERROR_1013: 1013;
+    readonly USAGE_LIMIT_EXCEEDED: 1037;
+    readonly MODEL_INCONSISTENT: 1050;
+    readonly MODEL_HEADER_INVALID: 1052;
+    readonly IP_TEMPORARILY_BLOCKED: 1060;
+};
+
+export declare const TEMPORARY_CHAT_FLAG_INDEX: number;
+
+export declare class AuthError extends Error { name: 'AuthError'; }
+export declare class APIError extends Error { name: 'APIError'; }
+export declare class ImageGenerationError extends APIError { name: 'ImageGenerationError'; }
+export declare class GeminiError extends Error { name: 'GeminiError'; }
+export declare class TimeoutError extends GeminiError { name: 'TimeoutError'; }
+export declare class UsageLimitExceeded extends GeminiError { name: 'UsageLimitExceeded'; }
+export declare class ModelInvalid extends GeminiError { name: 'ModelInvalid'; }
+export declare class TemporarilyBlocked extends GeminiError { name: 'TemporarilyBlocked'; }
+
+export interface ImageSaveOptions {
+    path?: string;
+    filename?: string;
+    cookies?: Record<string, string> | null;
+    verbose?: boolean;
+    skipInvalidFilename?: boolean;
+}
+
+export declare class Image {
+    url: string;
+    title: string;
+    alt: string;
+    proxy: string | null;
+    constructor(opts: { url: string; title?: string; alt?: string; proxy?: string | null });
+    save(opts?: ImageSaveOptions): Promise<string | null>;
+    toString(): string;
+}
+
+export declare class WebImage extends Image {}
+
+export interface GeneratedImageSaveOptions extends ImageSaveOptions {
+    fullSize?: boolean;
+}
+
+export declare class GeneratedImage extends Image {
+    cookies: Record<string, string>;
+    constructor(opts: { url: string; title?: string; alt?: string; proxy?: string | null; cookies: Record<string, string> });
+    save(opts?: GeneratedImageSaveOptions): Promise<string | null>;
+}
+
+export declare class Candidate {
+    rcid: string;
+    text: string;
+    text_delta: string | null;
+    thoughts: string | null;
+    thoughts_delta: string | null;
+    web_images: WebImage[];
+    generated_images: GeneratedImage[];
+    constructor(opts: {
+        rcid: string;
+        text: string;
+        text_delta?: string | null;
+        thoughts?: string | null;
+        thoughts_delta?: string | null;
+        web_images?: WebImage[];
+        generated_images?: GeneratedImage[];
+    });
+    get images(): (WebImage | GeneratedImage)[];
+    toString(): string;
+    repr(): string;
+}
+
+export declare class ModelOutput {
+    metadata: string[];
+    candidates: Candidate[];
+    chosen: number;
+    constructor(metadata: string[], candidates: Candidate[], chosen?: number);
+    get text(): string;
+    get text_delta(): string;
+    get thoughts(): string | null;
+    get thoughts_delta(): string;
+    get images(): (WebImage | GeneratedImage)[];
+    get rcid(): string;
+    toString(): string;
+    repr(): string;
+}
+
+export declare class ConversationTurn {
+    rid: string;
+    user_prompt: string;
+    assistant_response: string;
+    rcid: string;
+    thoughts: string | null;
+    timestamp: Date | null;
+    constructor(opts: {
+        rid: string;
+        user_prompt: string;
+        assistant_response: string;
+        rcid: string;
+        thoughts?: string | null;
+        timestamp?: Date | string | null;
+    });
+    toString(): string;
+    repr(): string;
+}
+
+export declare class Gem {
+    id: string;
+    name: string;
+    description: string | null;
+    prompt: string | null;
+    predefined: boolean;
+    constructor(opts: { id: string; name: string; description?: string | null; prompt?: string | null; predefined: boolean });
+    toString(): string;
+}
+
+export interface GemGetOptions {
+    id?: string | null;
+    name?: string | null;
+    defaultVal?: Gem | null;
+}
+
+export interface GemFilterOptions {
+    predefined?: boolean | null;
+    name?: string | null;
+}
+
+export declare class GemJar {
+    constructor(entries?: [string, Gem][]);
+    set(id: string, gem: Gem): void;
+    get(opts: GemGetOptions): Gem | null;
+    filter(opts?: GemFilterOptions): GemJar;
+    values(): Gem[];
+    keys(): string[];
+    entries(): [string, Gem][];
+    [Symbol.iterator](): Iterator<Gem>;
+    toObject(): Record<string, Gem>;
+}
+
+export declare class RPCData {
+    rpcid: string;
+    payload: string;
+    identifier: string;
+    constructor(opts: { rpcid: string; payload: string; identifier?: string });
+    serialize(): [string, string, null, string];
+    toString(): string;
+}
+
+export interface GeminiClientOptions {
+    secure_1psid?: string | null;
+    secure_1psidts?: string | null;
+    proxy?: string | null;
+    cookies?: Record<string, string>;
+}
+
+export interface InitOptions {
+    timeout?: number;
+    autoClose?: boolean;
+    closeDelay?: number;
+    autoRefresh?: boolean;
+    refreshInterval?: number;
+    verbose?: boolean;
+    watchdogTimeout?: number;
+}
+
+export interface GenerateOptions {
+    prompt: string;
+    files?: (string | Buffer)[] | null;
+    model?: ModelInput;
+    gem?: Gem | string | null;
+    chat?: ChatSession | null;
+    temporary?: boolean;
+}
+
+export interface StartChatOptions {
+    metadata?: string[] | null;
+    cid?: string | null;
+    rid?: string | null;
+    rcid?: string | null;
+    model?: ModelInput;
+    gem?: Gem | string | null;
+}
+
+export interface FetchGemsOptions {
+    includeHidden?: boolean;
+    language?: string;
+}
+
+export interface CreateGemOptions {
+    name: string;
+    prompt: string;
+    description?: string;
+}
+
+export interface UpdateGemOptions {
+    gem: Gem | string;
+    name: string;
+    prompt: string;
+    description?: string;
+}
+
+export declare class GeminiClient {
+    cookies: Record<string, string>;
+    proxy: string | null;
+    accessToken: string | null;
+    buildLabel: string | null;
+    sessionId: string | null;
+    timeout: number;
+    autoClose: boolean;
+    closeDelay: number;
+    autoRefresh: boolean;
+    refreshInterval: number;
+    verbose: boolean;
+    watchdogTimeout: number;
+
+    constructor(opts?: GeminiClientOptions);
+
+    init(opts?: InitOptions): Promise<void>;
+    close(delay?: number): Promise<void>;
+
+    generateContent(opts: GenerateOptions): Promise<ModelOutput>;
+    generateContentStream(opts: GenerateOptions): AsyncGenerator<ModelOutput>;
+
+    startChat(opts?: StartChatOptions): ChatSession;
+
+    fetchLatestChatResponse(cid: string): Promise<ModelOutput | null>;
+    readChat(cid: string, maxTurns?: number): Promise<ConversationTurn[]>;
+    deleteChat(cid: string): Promise<void>;
+
+    get gems(): GemJar;
+    fetchGems(opts?: FetchGemsOptions): Promise<GemJar>;
+    createGem(opts: CreateGemOptions): Promise<Gem>;
+    updateGem(opts: UpdateGemOptions): Promise<Gem>;
+    deleteGem(gem: Gem | string): Promise<void>;
+}
+
+export interface ChatSessionOptions {
+    geminiclient: GeminiClient;
+    metadata?: string[] | null;
+    cid?: string | null;
+    rid?: string | null;
+    rcid?: string | null;
+    model?: ModelInput;
+    gem?: Gem | string | null;
+}
+
+export interface SendMessageOptions {
+    prompt: string;
+    files?: (string | Buffer)[] | null;
+    temporary?: boolean;
+}
+
+export declare class ChatSession {
+    geminiclient: GeminiClient;
+    lastOutput: ModelOutput | null;
+    model: ModelDef;
+    gem: Gem | string | null;
+
+    constructor(opts: ChatSessionOptions);
+
+    get metadata(): string[];
+    set metadata(v: string[]);
+    get cid(): string;
+    set cid(v: string);
+    get rid(): string;
+    set rid(v: string);
+    get rcid(): string;
+    set rcid(v: string);
+
+    sendMessage(opts: SendMessageOptions): Promise<ModelOutput>;
+    sendMessageStream(opts: SendMessageOptions): AsyncGenerator<ModelOutput>;
+    chooseCandidate(index: number): ModelOutput;
+
+    toString(): string;
+}

package/index.js

@@ -0,0 +1,34 @@
+'use strict';
+
+const { GeminiClient, ChatSession } = require('./client');
+const { Model, GRPC, Endpoint, Headers, ErrorCode, TEMPORARY_CHAT_FLAG_INDEX } = require('./constants');
+const { AuthError, APIError, ImageGenerationError, GeminiError, TimeoutError, UsageLimitExceeded, ModelInvalid, TemporarilyBlocked } = require('./exceptions');
+const { Candidate, ConversationTurn, Gem, GemJar, RPCData, Image, WebImage, GeneratedImage, ModelOutput } = require('./types');
+
+module.exports = {
+    GeminiClient,
+    ChatSession,
+    Model,
+    GRPC,
+    Endpoint,
+    Headers,
+    ErrorCode,
+    TEMPORARY_CHAT_FLAG_INDEX,
+    AuthError,
+    APIError,
+    ImageGenerationError,
+    GeminiError,
+    TimeoutError,
+    UsageLimitExceeded,
+    ModelInvalid,
+    TemporarilyBlocked,
+    Candidate,
+    ConversationTurn,
+    Gem,
+    GemJar,
+    RPCData,
+    Image,
+    WebImage,
+    GeneratedImage,
+    ModelOutput,
+};

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "gemini-reverse",
+  "version": "1.0.0",
+  "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",
+  "license": "MIT",
+  "author": "rynn-k",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/rynn-k/gemini-core.git"
+  },
+  "bugs": {
+    "url": "https://github.com/rynn-k/gemini-core/issues"
+  },
+  "homepage": "https://github.com/rynn-k/gemini-core#readme",
+  "keywords": [
+    "gemini",
+    "google-gemini",
+    "gemini-api",
+    "nodejs",
+    "javascript",
+    "typescript",
+    "reverse-engineering",
+    "chatbot",
+    "ai",
+    "llm",
+    "unofficial"
+  ],
+  "dependencies": {
+    "axios": "^1.13.6",
+    "form-data": "^4.0.5",
+    "uuid": "^13.0.0"
+  }
+}

package/types/candidate.js

@@ -0,0 +1,39 @@
+'use strict';
+
+const { WebImage, GeneratedImage } = require('./image');
+
+class Candidate {
+    constructor({ rcid, text, text_delta = null, thoughts = null, thoughts_delta = null, web_images = [], generated_images = [] } = {}) {
+        this.rcid = rcid;
+        this.text = this._decodeHtml(text);
+        this.text_delta = text_delta;
+        this.thoughts = thoughts ? this._decodeHtml(thoughts) : null;
+        this.thoughts_delta = thoughts_delta;
+        this.web_images = web_images;
+        this.generated_images = generated_images;
+    }
+
+    _decodeHtml(str) {
+        if (!str) return str;
+        return str
+            .replace(/&/g, '&')
+            .replace(/&lt;/g, '<')
+            .replace(/&gt;/g, '>')
+            .replace(/&quot;/g, '"')
+            .replace(/&#39;/g, '\'')
+            .replace(/&apos;/g, '\'');
+    }
+
+    get images() {
+        return [...this.web_images, ...this.generated_images];
+    }
+
+    toString() { return this.text; }
+
+    repr() {
+        const preview = this.text.length <= 20 ? this.text : this.text.slice(0, 20) + '...';
+        return `Candidate(rcid='${this.rcid}', text='${preview}', images=${this.images.length})`;
+    }
+}
+
+module.exports = { Candidate };

package/types/conversation.js

@@ -0,0 +1,32 @@
+'use strict';
+
+class ConversationTurn {
+    constructor({ rid, user_prompt, assistant_response, rcid, thoughts = null, timestamp = null } = {}) {
+        this.rid = rid;
+        this.user_prompt = this._decodeHtml(user_prompt);
+        this.assistant_response = this._decodeHtml(assistant_response);
+        this.rcid = rcid;
+        this.thoughts = thoughts ? this._decodeHtml(thoughts) : null;
+        this.timestamp = timestamp instanceof Date ? timestamp : timestamp ? new Date(timestamp) : null;
+    }
+
+    _decodeHtml(str) {
+        if (!str) return str;
+        return str
+            .replace(/&/g, '&')
+            .replace(/&lt;/g, '<')
+            .replace(/&gt;/g, '>')
+            .replace(/&quot;/g, '"')
+            .replace(/&#39;/g, '\'')
+            .replace(/&apos;/g, '\'');
+    }
+
+    toString() { return this.assistant_response; }
+
+    repr() {
+        const preview = this.user_prompt.length > 30 ? this.user_prompt.slice(0, 30) + '...' : this.user_prompt;
+        return `ConversationTurn(rid='${this.rid}', prompt='${preview}')`;
+    }
+}
+
+module.exports = { ConversationTurn };

package/types/gem.js

@@ -0,0 +1,58 @@
+'use strict';
+
+class Gem {
+    constructor({ id, name, description = null, prompt = null, predefined } = {}) {
+        this.id = id;
+        this.name = name;
+        this.description = description;
+        this.prompt = prompt;
+        this.predefined = predefined;
+    }
+
+    toString() {
+        return `Gem(id='${this.id}', name='${this.name}', description='${this.description}', prompt='${this.prompt}', predefined=${this.predefined})`;
+    }
+}
+
+class GemJar {
+    constructor(entries = []) {
+        this._store = {};
+        for (const [id, gem] of entries) this._store[id] = gem;
+    }
+
+    set(id, gem) { this._store[id] = gem; }
+
+    get({ id = null, name = null, defaultVal = null } = {}) {
+        if (id == null && name == null) throw new Error('At least one of gem id or name must be provided.');
+        if (id != null) {
+            const gem = this._store[id];
+            if (!gem) return defaultVal;
+            if (name != null) return gem.name === name ? gem : defaultVal;
+            return gem;
+        }
+        for (const gem of Object.values(this._store)) {
+            if (gem.name === name) return gem;
+        }
+        return defaultVal;
+    }
+
+    filter({ predefined = null, name = null } = {}) {
+        const result = new GemJar();
+        for (const [id, gem] of Object.entries(this._store)) {
+            if (predefined != null && gem.predefined !== predefined) continue;
+            if (name != null && gem.name !== name) continue;
+            result.set(id, gem);
+        }
+        return result;
+    }
+
+    values() { return Object.values(this._store); }
+    keys() { return Object.keys(this._store); }
+    entries() { return Object.entries(this._store); }
+
+    [Symbol.iterator]() { return this.values()[Symbol.iterator](); }
+
+    toObject() { return { ...this._store }; }
+}
+
+module.exports = { Gem, GemJar };

package/types/grpc.js

@@ -0,0 +1,19 @@
+'use strict';
+
+class RPCData {
+    constructor({ rpcid, payload, identifier = 'generic' } = {}) {
+        this.rpcid = rpcid;
+        this.payload = payload;
+        this.identifier = identifier;
+    }
+
+    serialize() {
+        return [this.rpcid, this.payload, null, this.identifier];
+    }
+
+    toString() {
+        return `RPCData(rpcid='${this.rpcid}', payload='${this.payload}', identifier='${this.identifier}')`;
+    }
+}
+
+module.exports = { RPCData };