Using Gemini in Apps Script

/**
 * Translates an email from "Gen Z" slang into proper Victorian English.
 * @param {string} emailBody - The student's email text (e.g., "no cap this exam was mid").
 * @return {string} The translated text suitable for a 19th-century gentleman or scholar.
 */
function translateGenZtoVictorian_(emailBody) {
  const PROJECT_ID = "your-project-id";
  const REGION = "us-central1";
  const MODEL = `projects/${PROJECT_ID}/locations/${REGION}` +
    `/publishers/google/models/gemini-2.5-flash`;

  const model = MODEL; // back-compat for this snippet logic

  const prompt = `
    You are a distinguished Victorian-era scholar and translator. 
    Your task is to translate the following email, written in modern "Gen Z" slang, 
    into formal, elegant Victorian English. 
    
    Maintain the core meaning but completely change the tone to be exceedingly polite, 
    verbose, and aristocratic.

    Student's Email: "${emailBody}"
    
    Victorian Translation:
  `;

  const payload = {
    contents: [
      {
        role: "user",
        parts: [{ text: prompt }],
      },
    ],
    generationConfig: {
      temperature: 0.7,
    },
  };

  try {
    const response = VertexAI.Endpoints.generateContent(payload, model);
    const translation = response?.candidates?.[0]?.content?.parts?.[0]?.text;

    if (translation) {
      console.log(`Student said: ${emailBody}`);
      console.log(`Professor heard\n\n: ${translation}`);
      return translation;
    }
    return "Error: The telegram was lost in transit.";
  } catch (e) {
    console.error("Translation failed:", e.message);
    return "Error: An unfathomable calamity has occurred.";
  }
}

function runTranslatorDemo() {
  const studentEmail =
    "Hey prof, that lecture today was straight fire. The vibes were immaculate and I'm lowkey obsessed with this topic. Slay.";
  translateGenZtoVictorian_(studentEmail);
}

/**
 * Generates corporate jargon from a simple phrase using Gemini.
 * @param {string} simplePhrase - The simple phrase to translate (e.g., "I'm going to lunch").
 * @return {string} The corporate jargon version.
 */
function prioritizeSynergy_(simplePhrase) {
  const PROJECT_ID = "your-project-id";
  const REGION = "us-central1";
  const MODEL = `projects/${PROJECT_ID}/locations/${REGION}` +
    `/publishers/google/models/gemini-2.5-flash`;

  const model = MODEL;

  const prompt = `
    Rewrite the following simple phrase into overly complex, cringeworthy corporate jargon. 
    Make it sound like a LinkedIn thought leader who just discovered a thesaurus.
    
    Simple phrase: "${simplePhrase}"
  `;

  const payload = {
    contents: [
      {
        role: "user",
        parts: [{ text: prompt }],
      },
    ],
    generationConfig: {
      temperature: 0.9, // Max creativity for max cringe
    },
  };

  try {
    const response = VertexAI.Endpoints.generateContent(payload, model);

    // Safety check just in case the AI refuses to be that annoying
    const jargon = response?.candidates?.[0]?.content?.parts?.[0]?.text;

    if (jargon) {
      console.log(`Original: ${simplePhrase}`);
      console.log(`Corporate:\n\n${jargon}`);
      return jargon;
    } else {
      return "Error: Synergy levels critical. Please circle back.";
    }
  } catch (e) {
    console.error("Failed to leverage core competencies:", e.message);
    return "Error: Blocker identified.";
  }
}

function runDemo() {
  prioritizeSynergy_("I made a mistake.");
  prioritizeSynergy_("Can we meet later?");
  prioritizeSynergy_("I need a raise.");
}

/**
 * Analyzes an image using Gemini's multimodal capabilities.
 * @param {string} base64Image - The base64 encoded image string.
 * @param {string} mimeType - The mime type of the image (e.g., "image/jpeg").
 * @return {string} The model's description of the image.
 */
function analyzeImage_(data, mimeType) {
  const PROJECT_ID = "your-project-id";
  const REGION = "us-central1";
  const MODEL = `projects/${PROJECT_ID}/locations/${REGION}` +
    `/publishers/google/models/gemini-2.5-flash`;

  const model = MODEL;
  const payload = {
    contents: [
      {
        role: "user",
        parts: [
          { text: "Succintly describe what is happening in this image." },
          {
            inlineData: {
              mimeType,
              data,
            },
          },
        ],
      },
    ],
    generationConfig: {
      maxOutputTokens: 4096,
    },
  };

  try {
    const response = VertexAI.Endpoints.generateContent(payload, model);
    const description = response?.candidates?.[0]?.content?.parts?.[0]?.text;
    console.log(description);
    return description;
  } catch (e) {
    console.error("Analysis failed:", e.message);
    return "Error: Could not see the image.";
  }
}

function runMultimodalDemo() {
  // Fetch an image from the web (or Drive)
  const imageUrl =
    "https://media.githubusercontent.com/media/jpoehnelt/blog/refs/heads/main/apps/site/src/lib/images/mogollon-monster-100/justin-poehnelt-during-ultramarathon.jpeg";
  const imageBlob = UrlFetchApp.fetch(imageUrl).getBlob();
  const base64Image = Utilities.base64Encode(imageBlob.getBytes());
  const mimeType = imageBlob.getContentType() || "image/jpeg";
  analyzeImage_(base64Image, mimeType);
}

/**
 * Force Gemini to return valid JSON matching your schema.
 */
function analyzeWithSchema(text) {
  const PROJECT_ID = "your-project-id";
  const REGION = "us-central1";
  const MODEL = `projects/${PROJECT_ID}/locations/${REGION}` +
    `/publishers/google/models/gemini-2.5-flash`;

  const payload = {
    contents: [{
      role: "user",
      parts: [{ text: `Analyze: "${text}"` }],
    }],
    generationConfig: {
      responseMimeType: "application/json",
      responseSchema: {
        type: "object",
        properties: {
          sentiment: {
            type: "string",
            enum: ["positive", "negative", "neutral"],
          },
          topics: {
            type: "array",
            items: { type: "string" },
          },
          confidence: { type: "number" },
        },
        required: ["sentiment", "topics", "confidence"],
      },
    },
  };

  const response = VertexAI.Endpoints.generateContent(payload, MODEL);
  return JSON.parse(response.candidates[0].content.parts[0].text);
}

/**
 * Enable Google Search for real-time info with citations.
 */
function searchGrounded(query) {
  const PROJECT_ID = "your-project-id";
  const REGION = "us-central1";
  const MODEL = `projects/${PROJECT_ID}/locations/${REGION}` +
    `/publishers/google/models/gemini-2.5-flash`;

  const payload = {
    contents: [{
      role: "user",
      parts: [{ text: query }],
    }],
    tools: [{ googleSearch: {} }],
  };

  const response = VertexAI.Endpoints.generateContent(payload, MODEL);
  const candidate = response.candidates[0];
  const meta = candidate.groundingMetadata;

  return {
    text: candidate.content.parts[0].text,
    sources: meta?.groundingChunks || [],
    queries: meta?.webSearchQueries || [],
  };
}

/**
 * Set persistent persona/rules with systemInstruction.
 */
function queryWithSystem(prompt) {
  const PROJECT_ID = "your-project-id";
  const REGION = "us-central1";
  const MODEL = `projects/${PROJECT_ID}/locations/${REGION}` +
    `/publishers/google/models/gemini-2.5-flash`;

  const payload = {
    systemInstruction: {
      parts: [{
        text: `You are a helpful assistant. Be concise.
Use bullet points for lists.`,
      }],
    },
    contents: [{
      role: "user",
      parts: [{ text: prompt }],
    }],
  };

  const response = VertexAI.Endpoints.generateContent(payload, MODEL);
  return response.candidates[0].content.parts[0].text;
}

/**
 * Multi-turn: pass conversation history in contents.
 */
function chat(history, message) {
  const PROJECT_ID = "your-project-id";
  const REGION = "us-central1";
  const MODEL = `projects/${PROJECT_ID}/locations/${REGION}` +
    `/publishers/google/models/gemini-2.5-flash`;

  history.push({
    role: "user",
    parts: [{ text: message }],
  });

  const response = VertexAI.Endpoints.generateContent(
    { contents: history },
    MODEL
  );
  const reply = response.candidates[0].content.parts[0].text;

  history.push({
    role: "model",
    parts: [{ text: reply }],
  });

  return { reply, history };
}

/**
 * Adjust content filtering thresholds.
 * Thresholds: BLOCK_LOW_AND_ABOVE, BLOCK_MEDIUM_AND_ABOVE,
 *             BLOCK_ONLY_HIGH, BLOCK_NONE
 */
function queryWithSafety(prompt) {
  const PROJECT_ID = "your-project-id";
  const REGION = "us-central1";
  const MODEL = `projects/${PROJECT_ID}/locations/${REGION}` +
    `/publishers/google/models/gemini-2.5-flash`;

  const payload = {
    contents: [{
      role: "user",
      parts: [{ text: prompt }],
    }],
    safetySettings: [
      {
        category: "HARM_CATEGORY_HARASSMENT",
        threshold: "BLOCK_ONLY_HIGH",
      },
      {
        category: "HARM_CATEGORY_HATE_SPEECH",
        threshold: "BLOCK_ONLY_HIGH",
      },
      {
        category: "HARM_CATEGORY_SEXUALLY_EXPLICIT",
        threshold: "BLOCK_ONLY_HIGH",
      },
      {
        category: "HARM_CATEGORY_DANGEROUS_CONTENT",
        threshold: "BLOCK_ONLY_HIGH",
      },
    ],
  };

  const response = VertexAI.Endpoints.generateContent(payload, MODEL);
  const candidate = response.candidates[0];

  if (candidate.finishReason === "SAFETY") {
    return { blocked: true, ratings: candidate.safetyRatings };
  }
  return { blocked: false, text: candidate.content.parts[0].text };
}

/**
 * Analyze form responses with Gemini.
 * Set up an "On form submit" trigger.
 */
function onFormSubmit(e) {
  const PROJECT_ID = "your-project-id";
  const REGION = "us-central1";
  const MODEL = `projects/${PROJECT_ID}/locations/${REGION}` +
    `/publishers/google/models/gemini-2.5-flash`;

  const sheet = e.range.getSheet();
  const row = e.range.getRow();
  const feedback = e.values[2];

  const payload = {
    contents: [{
      role: "user",
      parts: [{ text: `Analyze: "${feedback}"` }],
    }],
    generationConfig: {
      responseMimeType: "application/json",
      responseSchema: {
        type: "object",
        properties: {
          sentiment: {
            type: "string",
            enum: ["positive", "negative", "neutral"],
          },
          summary: { type: "string" },
          priority: {
            type: "string",
            enum: ["high", "medium", "low"],
          },
        },
        required: ["sentiment", "summary", "priority"],
      },
    },
  };

  const response = VertexAI.Endpoints.generateContent(payload, MODEL);
  const json = response.candidates[0].content.parts[0].text;
  const result = JSON.parse(json);

  sheet.getRange(row, 4, 1, 3).setValues([
    [result.sentiment, result.summary, result.priority],
  ]);
}

/**
 * Triage unread emails. Run on a time-based trigger.
 */
function triageInbox() {
  const PROJECT_ID = "your-project-id";
  const REGION = "us-central1";
  const MODEL = `projects/${PROJECT_ID}/locations/${REGION}` +
    `/publishers/google/models/gemini-2.5-flash`;

  const threads = GmailApp.search("is:unread newer_than:1h", 0, 10);

  threads.forEach((thread) => {
    const msg = thread.getMessages().pop();
    const prompt = `Summarize and rate urgency (HIGH/MEDIUM/LOW):
From: ${msg.getFrom()}
Subject: ${thread.getFirstMessageSubject()}
Body: ${msg.getPlainBody().substring(0, 1000)}`;

    const payload = {
      contents: [{
        role: "user",
        parts: [{ text: prompt }],
      }],
    };

    const response = VertexAI.Endpoints.generateContent(payload, MODEL);
    const analysis = response.candidates[0].content.parts[0].text;

    if (analysis.includes("HIGH")) {
      const label = GmailApp.getUserLabelByName("AI/Urgent")
        || GmailApp.createLabel("AI/Urgent");
      thread.addLabel(label);
    }

    console.log(`${thread.getFirstMessageSubject()}: ${analysis}`);
  });
}

/**
 * Scan receipt images and rename with extracted metadata.
 */
function organizeReceipts() {
  const PROJECT_ID = "your-project-id";
  const REGION = "us-central1";
  const MODEL = `projects/${PROJECT_ID}/locations/${REGION}` +
    `/publishers/google/models/gemini-2.5-flash`;

  const folder = DriveApp.getFoldersByName("Receipts").next();
  const files = folder.getFiles();

  while (files.hasNext()) {
    const file = files.next();
    if (!file.getMimeType().startsWith("image/")) continue;

    const blob = file.getBlob();
    const base64 = Utilities.base64Encode(blob.getBytes());

    const payload = {
      contents: [{
        role: "user",
        parts: [
          { text: "Extract: vendor, date (YYYY-MM-DD), amount. JSON." },
          {
            inlineData: {
              mimeType: file.getMimeType(),
              data: base64,
            },
          },
        ],
      }],
      generationConfig: { responseMimeType: "application/json" },
    };

    const response = VertexAI.Endpoints.generateContent(payload, MODEL);
    const json = response.candidates[0].content.parts[0].text;
    const data = JSON.parse(json);

    const newName = `${data.date}_${data.vendor}_${data.amount}.jpg`;
    file.setName(newName);
    console.log(`Renamed: ${newName}`);
  }
}

/**
 * Rewrite selected text in Docs. Add menu via onOpen().
 */
function rewriteSelection(style) {
  const PROJECT_ID = "your-project-id";
  const REGION = "us-central1";
  const MODEL = `projects/${PROJECT_ID}/locations/${REGION}` +
    `/publishers/google/models/gemini-2.5-flash`;

  const doc = DocumentApp.getActiveDocument();
  const selection = doc.getSelection();
  if (!selection) {
    return DocumentApp.getUi().alert("Select text first.");
  }

  const el = selection.getRangeElements()[0];
  const text = el.getElement().asText();
  const start = el.getStartOffset();
  const end = el.getEndOffsetInclusive();
  const selected = text.getText().substring(start, end + 1);

  const styles = {
    formal: "Rewrite formally:",
    casual: "Rewrite casually:",
    concise: "Make concise:",
  };

  const payload = {
    contents: [{
      role: "user",
      parts: [{ text: `${styles[style]} "${selected}"` }],
    }],
  };

  const response = VertexAI.Endpoints.generateContent(payload, MODEL);
  const rewritten = response.candidates[0].content.parts[0].text.trim();

  text.deleteText(start, end);
  text.insertText(start, rewritten);
}

function onOpen() {
  DocumentApp.getUi()
    .createMenu("✨ AI")
    .addItem("Formal", "rewriteFormal")
    .addItem("Casual", "rewriteCasual")
    .addItem("Concise", "rewriteConcise")
    .addToUi();
}

function rewriteFormal() { rewriteSelection("formal"); }
function rewriteCasual() { rewriteSelection("casual"); }
function rewriteConcise() { rewriteSelection("concise"); }

/**
 * Daily briefing from calendar. Run on morning trigger.
 */
function generateBriefing() {
  const PROJECT_ID = "your-project-id";
  const REGION = "us-central1";
  const MODEL = `projects/${PROJECT_ID}/locations/${REGION}` +
    `/publishers/google/models/gemini-2.5-flash`;

  const today = new Date();
  const tomorrow = new Date(today.getTime() + 86400000);
  const calendar = CalendarApp.getDefaultCalendar();
  const events = calendar.getEvents(today, tomorrow);

  const list = events.map((e) => {
    const time = e.getStartTime().toLocaleTimeString();
    return `- ${time}: ${e.getTitle()}`;
  }).join("\n");

  const payload = {
    contents: [{
      role: "user",
      parts: [{ text: `Create brief agenda with prep notes:\n${list}` }],
    }],
  };

  const response = VertexAI.Endpoints.generateContent(payload, MODEL);
  const briefing = response.candidates[0].content.parts[0].text;

  const doc = DocumentApp.create(`Briefing ${today.toLocaleDateString()}`);
  doc.getBody().appendParagraph(briefing);

  GmailApp.sendEmail(
    Session.getActiveUser().getEmail(),
    "☀️ Daily Briefing",
    `${doc.getUrl()}\n\n${briefing}`
  );
}