I Built a Gmail AI Responder in Node.js (and it Actually Works)

gmail-responder/

├── src/

│   ├── index.js      # orchestration

│   ├── auth.js       # Google OAuth2

│   ├── gmail.js      # Gmail API wrapper

│   └── openai.js     # prompt + OpenAI call

├── .env

└── google-credentials.json

// src/auth.js

import { authenticate } from '@google-cloud/local-auth';

import { google } from 'googleapis';

import fs from 'fs';

import path from 'path';



const SCOPES = ['https://www.googleapis.com/auth/gmail.modify'];

const TOKEN_PATH = path.resolve('./google-credentials-token.json');

const CREDENTIALS_PATH = path.resolve(process.env.GOOGLE_CREDENTIALS_PATH);



export async function getGmailClient() {

  let client = await loadSavedToken();

  if (!client) {

    client = await authenticate({ scopes: SCOPES, keyfilePath: CREDENTIALS_PATH });

    await saveToken(client);

  }

  return google.gmail({ version: 'v1', auth: client });

}

// src/gmail.js

export async function getLabelId(gmail, labelName) {

  const res = await gmail.users.labels.list({ userId: 'me' });

  const label = res.data.labels.find(l => l.name === labelName);

  return label?.id ?? null;

}



export async function getThreadsWithLabel(gmail, labelId) {

  const res = await gmail.users.threads.list({

    userId: 'me',

    labelIds: [labelId],

    maxResults: 10,

  });

  return res.data.threads ?? [];

}

export function parseMessage(msg) {

  const headers = msg.payload.headers.reduce((acc, h) => {

    acc[h.name] = h.value;

    return acc;

  }, {});



  const getBody = (payload) => {

    if (payload.body?.data) {

      return Buffer.from(payload.body.data, 'base64url').toString('utf-8');

    }

    if (payload.parts) {

      const textPart = payload.parts.find(p => p.mimeType === 'text/plain');

      if (textPart?.body?.data) {

        return Buffer.from(textPart.body.data, 'base64url').toString('utf-8');

      }

    }

    return '';

  };



  return { headers, body: getBody(msg.payload) };

}

export async function getDraftForThread(gmail, threadId) {

  const res = await gmail.users.drafts.list({ userId: 'me' });

  const drafts = res.data.drafts ?? [];



  for (const draft of drafts) {

    const full = await gmail.users.drafts.get({ userId: 'me', id: draft.id });

    if (full.data.message.threadId === threadId) {

      return { id: draft.id, message: full.data.message };

    }

  }

  return null;

}

// src/openai.js

export async function improveDraft(client, threadMessages, draft) {

  const threadContext = threadMessages

    .map(m => `From: ${m.headers.From}\n\n${m.body}`)

    .join('\n\n---\n\n');



  const prompt = `

You are a professional email assistant.

Here is the email thread for context:



${threadContext}



Here is the draft reply to improve:



${draft}



Rewrite the draft to be clearer, more concise, and professional.

Keep the original intent. Return only the improved email body.

  `;



  const res = await client.chat.completions.create({

    model: process.env.OPENAI_MODEL ?? 'gpt-4.1',

    messages: [{ role: 'user', content: prompt }],

  });



  return res.choices[0].message.content.trim();

}

export async function updateDraft(gmail, draftId, originalMessage, newBody) {

  const headers = [

    `From: ${originalMessage.headers.From}`,

    `To: ${originalMessage.headers.To}`,

    `Subject: ${originalMessage.headers.Subject}`,

    `References: ${originalMessage.headers.References ?? ''}`,

    `In-Reply-To: ${originalMessage.headers['In-Reply-To'] ?? ''}`,

    'Content-Type: text/plain; charset=utf-8',

    '',

    newBody,

  ].join('\r\n');



  const encoded = Buffer.from(headers).toString('base64url');



  await gmail.users.drafts.update({

    userId: 'me',

    id: draftId,

    requestBody: {

      message: {

        raw: encoded,

        threadId: originalMessage.threadId,

      },

    },

  });

}

const threads = await getThreadsWithLabel(gmail, labelId);



for (const thread of threads) {

  const draft = await getDraftForThread(gmail, thread.id);

  if (!draft) continue;



  const messages = await getThreadMessages(gmail, thread.id);

  const draftMessage = parseMessage(draft.message);

  const improved = await improveDraft(openai, messages, draftMessage.body);



  await updateDraft(gmail, draft.id, draftMessage, improved);

  await removeLabelFromThread(gmail, thread.id, labelId);



  console.log(`Updated draft for thread ${thread.id}`);

}

git clone https://github.com/alagrede/gmail-responder

cd gmail-responder

npm install

GMAIL_LABEL=znote

OPENAI_API_KEY=sk-...

OPENAI_MODEL=gpt-4.1

GOOGLE_CREDENTIALS_PATH=./google-credentials.json

npm start