const { Gemini } = require('gemini-reverse');

const client = new Gemini({
    secure_1psid: 'YOUR_SECURE_1PSID',
    proxy: null,                            // optional, e.g. 'http://host:port'
    timeout: 300000,                        // request timeout in ms, default 300000
    autoClose: false,                       // auto-close client after inactivity
    closeDelay: 300000,                     // inactivity delay before closing in ms
    verbose: false,                         // enable verbose logging
});

await client.init(); // optional — called automatically on first use

const { Gemini } = require('gemini-reverse');

const client = new Gemini(); // no credentials needed

const chat = client.newChat();

const r1 = await chat.generateContent({ prompt: 'My name is Rynn.' });
console.log(r1.text);

const r2 = await chat.generateContent({ prompt: 'What is my name?' });
console.log(r2.text); // remembers "Rynn" from the previous turn

const { Gemini } = require('gemini-reverse');

const client = new Gemini({ secure_1psid: 'YOUR_COOKIE' });
const chat = client.newChat();

const response = await chat.generateContent({ prompt: 'What is the capital of France?' });
console.log(response.text);

const { Gemini, Model } = require('gemini-reverse');

const client = new Gemini({ secure_1psid: 'YOUR_COOKIE' });

const response = await client.ask('What is 2 + 2?');
console.log(response.text);

// With options
const response2 = await client.ask('Explain gravity.', {
    model: Model.BASIC_FLASH,
    temporary: true,
});
console.log(response2.text);

{
  // ── Identifiers ────────────────────────
  cid:     'c_abc123',          // conversation ID
  rid:     'r_def456',          // response ID
  rcid:    'rc_xyz789',         // chosen candidate's rcid

  // ── Info ───────────────────────────────
  model:   'gemini-3-flash',    // model used
  gem:     null,                // gem ID if used
  created: 1750123456789,       // timestamp

  // ── Candidates ─────────────────────────
  candidates: [
    {
      index:    0,
      rcid:     'rc_xyz789',
      text:     'Paris is the capital of France.',
      thoughts: null,
      images:   [],
      videos:   [],
      media:    [],
      done:     true,
    },
  ],
}

const chat = client.newChat();
const response = await chat.generateContent({
    prompt: 'Describe what you see in this image.',
    files: ['./photo.png'],
});
console.log(response.text);

const { Gemini } = require('gemini-reverse');

const client = new Gemini({ secure_1psid: 'YOUR_COOKIE' });
const chat = client.newChat();

const res1 = await chat.generateContent({ prompt: 'My name is Alice.' });
console.log(res1.text);

const res2 = await chat.generateContent({ prompt: 'What is my name?' });
console.log(res2.text); // remembers "Alice"

const res3 = await chat.generateContent({ prompt: 'Tell me a joke.' });
console.log(res3.text);

const chat = client.newChat();
await chat.generateContent({ prompt: 'Fine weather today.' });

// Persist the metadata
const savedMetadata = chat.metadata;

// Resume in a new process / session
const previousChat = client.newChat({ metadata: savedMetadata });
const response = await previousChat.generateContent({ prompt: 'What did I say before?' });
console.log(response.text);

const chat = client.newChat();
await chat.generateContent({ prompt: 'What is the tallest mountain?' });

const history = await client.readChat(chat.cid, 10); // limit to 10 turns
for (const turn of history) {
    console.log(`[${turn.role.toUpperCase()}] ${turn.text}`);
}

const chatList = await client.chats();
for (const info of chatList) {
    console.log(`[${info.cid}] ${info.title} — pinned: ${info.pinned}`);
}

const chat = client.newChat();
await chat.generateContent({ prompt: 'This is a temporary conversation.' });

await client.deleteChat(chat.cid);
// or: await chat.delete();

const chat = client.newChat({ temporary: true });

const res1 = await chat.generateContent({ prompt: 'Hello!' });
console.log(res1.text);

const res2 = await chat.generateContent({ prompt: 'What did I say?' });
console.log(res2.text); // still remembers within the same session

const chat = client.newChat();
for await (const chunk of chat.generateContentStream({ prompt: 'Explain quantum entanglement.' })) {
    process.stdout.write(chunk.text_delta);
    if (chunk.done) console.log('\n[done]');
}

{
  cid:   'c_abc123',
  rid:   'r_def456',
  model: 'gemini-3-flash',
  done:  false,              // true on last chunk
  candidates: [
    {
      index:          0,
      text_delta:     'Par',
      thoughts_delta: null,
      done:           false,
    },
  ],
}

const { Gemini, Model } = require('gemini-reverse');

const chat = client.newChat({ model: Model.ADVANCED_PRO });
const response = await chat.generateContent({
    prompt: 'Solve step by step: If a train travels at 120 km/h and needs to cover 450 km, how long does it take?',
    extended_thinking: true,
});

if (response.thoughts) {
    console.log('Thinking process:', response.thoughts);
}
console.log('Answer:', response.text);

const { Gemini, Model } = require('gemini-reverse');

// Using a built-in constant
const chat1 = client.newChat({ model: Model.BASIC_FLASH });

// Using a model name string (case-insensitive)
const chat2 = client.newChat({ model: 'gemini-3-pro' });

// Using a custom model header object
const chat3 = client.newChat({
    model: {
        model_name: 'custom',
        model_header: {
            'x-goog-ext-525001261-jspb': '[1,null,null,null,"MODEL_ID",null,null,0,[4,6],null,null,1,null,null,1]',
            'x-goog-ext-73010989-jspb': '[0]',
            'x-goog-ext-73010990-jspb': '[0,0,0]',
        },
    },
});

const modelList = await client.models();
for (const model of modelList) {
    console.log(`${model.model_id} → ${model.model_name} (${model.display_name})`);
    console.log(`  capacity: ${model.capacity}, available: ${model.is_available}`);
}

const gemList = await client.gems();
const codingGem = gemList.find(g => g.name === 'Coding partner');

const chat = client.newChat({ gem: codingGem });
const response = await chat.generateContent({ prompt: 'Help me write a binary search in JavaScript.' });
console.log(response.text);

const newGem = await client.addGem({
    name: 'Python Tutor',
    prompt: 'You are a helpful Python programming tutor. Always provide runnable code examples.',
    description: 'A specialized gem for Python programming',
});

console.log(`Created: ${newGem.id}`);

const updatedGem = await client.setGem({
    gem: newGem, // or a gem ID string
    name: 'Advanced Python Tutor',
    prompt: 'You are an expert Python tutor. Focus on performance and best practices.',
    description: 'An advanced Python programming assistant',
});

await client.delGem(newGem); // or pass a gem ID string

const { Gemini, Model } = require('gemini-reverse');

const client = new Gemini({ secure_1psid: 'YOUR_COOKIE' });
const chat = client.newChat({ model: Model.BASIC_FLASH });
const response = await chat.generateContent({ prompt: 'What is 17 × 23?' });

if (response.thoughts) {
    console.log('Thoughts:', response.thoughts);
}
console.log('Answer:', response.text);

const chat = client.newChat();
const response = await chat.generateContent({ prompt: 'Show me pictures of cats.' });

for (const image of response.images) {
    console.log(`URL: ${image.url}`);
    console.log(`Alt: ${image.alt}`);
}

const chat = client.newChat();
const response = await chat.generateContent({
    prompt: 'Generate a photo-realistic image of a cat astronaut floating in space.',
});

for (const image of response.images) {
    const savedPath = await image.save({
        path: './output',
        verbose: true,
    });
    console.log('Saved to:', savedPath);
}

const saved = await response.saveAll({ path: './output', verbose: true });
// { images: ['./output/...jpg'], videos: [...], media: [...] }

const res1 = await chat.generateContent({
    prompt: 'Generate an image of a sunset over the ocean.',
});

// Follow up in the same chat session to edit
const res2 = await chat.generateContent({
    prompt: 'Now add a sailboat in the foreground.',
});

for (const image of res2.images) {
    await image.save({ path: './output', verbose: true });
}

const chat = client.newChat();
const response = await chat.generateContent({
    prompt: 'Generate a short video of a sunset over the ocean with waves.',
});

for (const video of response.videos) {
    console.log('Video URL:', video.url);
    console.log('Thumbnail:', video.thumbnail);

    const result = await video.save({
        savePath: './output',
        verbose: true,
    });

    console.log('Saved video:', result.video);
    console.log('Saved thumbnail:', result.video_thumbnail);
}

const chat = client.newChat();
const response = await chat.generateContent({
    prompt: 'Compose a short upbeat piano melody, 15 seconds long.',
});

for (const media of response.media) {
    console.log('MP3 URL:', media.mp3_url);
    console.log('MP4 URL:', media.url);

    const result = await media.save({
        savePath: './output',
        verbose: true,
    });

    console.log('MP4 saved:', result.mp4);
    console.log('MP3 saved:', result.mp3);
}

const chat = client.newChat();

const gmailResponse = await chat.generateContent({
    prompt: "@Gmail What's the latest message in my inbox?",
});
console.log(gmailResponse.text);

const youtubeResponse = await chat.generateContent({
    prompt: "@YouTube What's the latest video from Fireship?",
});
console.log(youtubeResponse.text);

const chat = client.newChat();
const response = await chat.generateContent({ prompt: 'Recommend a sci-fi book.' });

// Access all candidates directly
response.candidates.forEach((c, i) => {
    console.log(`[${i}] ${c.text.slice(0, 80)}...`);
});

// Switch to the second candidate
if (response.candidates.length > 1) {
    chat.chooseCandidate(1);
}

const followup = await chat.generateContent({ prompt: 'Tell me more about it.' });
console.log(followup.text);

const result = await client.research(
    'Compare the top 3 cloud providers and their AI offerings',
    {
        wait: true,
        pollInterval: 10000,
        timeout: 600000,
        onStatus: (status) => console.log(`Status: ${status.state}`),
    }
);

console.log(result.text);

// Step 1: Create a research plan
const chat = client.newChat();
const plan = await client._createDeepResearchPlan(
    'What are the latest advancements in quantum computing?',
    chat
);

console.log(`Title: ${plan.title}`);
console.log(`ETA: ${plan.eta_text}`);

// Step 2: Start the research
await client._startDeepResearch(plan, chat);

// Step 3: Poll for completion
const result = await client._waitDeepResearch(
    plan,
    10000,   // poll interval in ms
    600000,  // timeout in ms
    (status) => console.log(`[${status.state}] ${status.notes?.[0] || ''}`)
);

console.log(result.text);

const {
    AuthError,
    APIError,
    GeminiError,
    UsageLimitExceeded,
    ModelInvalid,
    TemporarilyBlocked,
} = require('gemini-reverse');

try {
    const response = await chat.generateContent({ prompt: 'Hello!' });
    console.log(response.text);
} catch (e) {
    if (e instanceof AuthError) {
        console.error('Cookie expired or invalid. Please refresh your cookies.');
    } else if (e instanceof UsageLimitExceeded) {
        console.error('Usage limit reached. Try again later or switch to a different model.');
    } else if (e instanceof TemporarilyBlocked) {
        console.error('IP temporarily blocked by Google. Try using a proxy or wait a while.');
    } else if (e instanceof ModelInvalid) {
        console.error('Invalid or unavailable model. Try a different model.');
    } else if (e instanceof APIError) {
        console.error('API error:', e.message);
    } else {
        throw e;
    }
}