How to Handle Gemini API Model Deprecation and Migration Errors

curl https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-pro:generateContent \
  -H "Content-Type: application/json" \
  -H "x-goog-api-key: YOUR_API_KEY" \
  -d '{
    "contents": [{"parts": [{"text": "Hello world"}]}]
  }' \
  -v

const { GoogleGenerativeAI } = require("@google/generative-ai");
 
const client = new GoogleGenerativeAI({
  apiKey: process.env.GEMINI_API_KEY,
});
 
async function testMigration() {
  try {
    // Specify the new model
    const model = client.getGenerativeModel({
      model: "gemini-2.0-pro",
    });
 
    const response = await model.generateContent(
      "What is your model version?"
    );
 
    console.log("Model test passed:", response.text());
 
    // Test critical features
    await testFunctionCalling(model);
    await testMultimodalInput(model);
    await testResponseFormat(response);
  } catch (error) {
    console.error("Test failed:", error.message);
    process.exit(1);
  }
}
 
async function testFunctionCalling(model) {
  // Ensure function calling still works
  const response = await model.generateContent({
    contents: [
      {
        parts: [
          {
            text: "Get the weather for Tokyo",
          },
        ],
      },
    ],
    tools: [
      {
        functionDeclarations: [
          {
            name: "getWeather",
            description: "Get weather for a city",
            parameters: {
              type: "object",
              properties: {
                city: {
                  type: "string",
                  description: "City name",
                },
              },
              required: ["city"],
            },
          },
        ],
      },
    ],
  });
 
  console.log("Function calling works:", !!response.functionCalls);
}
 
async function testMultimodalInput(model) {
  // Verify image processing
  const fs = require("fs");
  const imageData = fs.readFileSync("test-image.jpg");
  const base64 = imageData.toString("base64");
 
  const response = await model.generateContent({
    contents: [
      {
        parts: [
          {
            inlineData: {
              mimeType: "image/jpeg",
              data: base64,
            },
          },
          {
            text: "Describe what you see in this image",
          },
        ],
      },
    ],
  });
 
  console.log("Image processing works:", response.text().length > 0);
}
 
async function testResponseFormat(response) {
  // Verify response structure hasn't changed
  console.log("Usage metadata available:", !!response.usageMetadata);
  console.log("Text method works:", typeof response.text === "function");
}
 
testMigration();

// Control which model to use via environment variable
const targetModel =
  process.env.USE_NEW_MODEL === "true" ? "gemini-2.0-pro" : "gemini-1.5-pro";
 
const model = client.getGenerativeModel({
  model: targetModel,
});

const DEPRECATED_MODELS = ["gemini-1.5-pro"];
 
function validateModelName(modelName) {
  if (DEPRECATED_MODELS.includes(modelName)) {
    throw new Error(
      `Model ${modelName} has been sunset. Please use gemini-2.0-pro instead.`
    );
  }
  return true;
}

# Find all occurrences
grep -r "gemini-1.5-pro" src/
 
# Replace with new model name
sed -i 's/gemini-1.5-pro/gemini-2.0-pro/g' src/**/*.js

// Old code (deprecated model)
const response = await model.generateContent({
  contents: [{ parts: [{ text: "Hello" }] }],
  safety_settings: [
    {
      category: "HARM_CATEGORY_HATE_SPEECH",
      threshold: "BLOCK_NONE",
    },
  ],
});
 
// New code (new model)
const response = await model.generateContent({
  contents: [{ parts: [{ text: "Hello" }] }],
  safetySettings: [
    {
      category: "HARM_CATEGORY_HATE_SPEECH",
      threshold: "BLOCK_NONE",
    },
  ],
});

function safeGetText(response) {
  // Try new format first
  if (response.text && typeof response.text === "function") {
    return response.text();
  }
 
  // Try old format
  if (response.content && response.content[0]) {
    return response.content[0].parts[0].text;
  }
 
  // Fallback
  return null;
}

async function checkTokenCount(prompt) {
  const model = client.getGenerativeModel({
    model: "gemini-2.0-pro",
  });
 
  const countResult = await model.countTokens(prompt);
 
  if (countResult.totalTokens > 1000000) {
    console.warn("Input too long. Split into smaller chunks.");
    return false;
  }
 
  return true;
}

async function generateWithFallback(prompt, options = {}) {
  const models = ["gemini-3.1-pro", "gemini-3.5-flash"];
  let lastError = null;
 
  for (const modelName of models) {
    try {
      console.log(`Trying ${modelName}...`);
 
      const model = client.getGenerativeModel({
        model: modelName,
      });
 
      const response = await model.generateContent({
        contents: [{ parts: [{ text: prompt }] }],
        ...options,
      });
 
      console.log(`Success with ${modelName}`);
      return response;
    } catch (error) {
      lastError = error;
      console.warn(`Failed with ${modelName}: ${error.message}`);
    }
  }
 
  throw new Error(`All models failed: ${lastError.message}`);
}
 
// Usage
const response = await generateWithFallback("Explain quantum computing");
console.log(response.text());

async function rollback() {
  console.log("Rolling back to old model...");
  process.env.USE_NEW_MODEL = "false";
  // Restart your application
  process.exit(0);
}
 
// Trigger this if error rate exceeds threshold
if (errorRate > 0.05) {
  await rollback();
}

// audit-models.mjs — inventory model names in the repo and check them against sunset dates
import { readdir, readFile } from "node:fs/promises";
import { join, extname } from "node:path";
 
// Sunset dates (maintained by hand, or pulled from the deprecations doc)
const SUNSET = {
  "gemini-3.1-flash-image-preview": "2026-06-25",
  "gemini-3-pro-image-preview": "2026-06-25",
};
 
const MODEL_RE = /gemini-[a-z0-9.\-]+/g;
const SKIP = new Set(["node_modules", ".git", ".next", "dist", "build"]);
 
async function* walk(dir) {
  for (const ent of await readdir(dir, { withFileTypes: true })) {
    if (SKIP.has(ent.name)) continue;
    const p = join(dir, ent.name);
    if (ent.isDirectory()) yield* walk(p);
    else if ([".js", ".mjs", ".ts", ".tsx", ".json"].includes(extname(ent.name))) yield p;
  }
}
 
const hits = new Map(); // model -> Set<file>
for await (const file of walk(process.cwd())) {
  const text = await readFile(file, "utf8");
  for (const m of text.matchAll(MODEL_RE)) {
    if (!hits.has(m[0])) hits.set(m[0], new Set());
    hits.get(m[0]).add(file);
  }
}
 
const today = new Date();
let risk = 0;
for (const [model, files] of [...hits].sort()) {
  const sunset = SUNSET[model];
  const days = sunset ? Math.ceil((new Date(sunset) - today) / 86400000) : null;
  const flag = days != null && days <= 30 ? `⚠️ ${days} days left (${sunset})` : "";
  if (flag) risk++;
  console.log(`${model.padEnd(36)} ${files.size} file(s) ${flag}`);
}
process.exit(risk > 0 ? 1 : 0);

// config/models.mjs — always reference model names through here
export const MODELS = {
  draft: "gemini-3.5-flash",   // high-frequency, low-cost work like drafting and classification
  finalize: "gemini-3.1-pro",  // work that needs stronger reasoning
};