Why Gemini API Returns Empty Responses with finishReason: RECITATION, and the Prompt + Post-Processing Design That Stopped It

function buildParaphrasePrompt(sourceText: string, task: string): string {
  return [
    "You are a writer who restructures information. The [SOURCE] below is for",
    "reference only. Strict constraints:",
    "",
    "- Never reuse a sequence of 10 or more consecutive words from the source",
    "- Paraphrase every sentence (reorder, swap synonyms, restructure)",
    "- Do not reproduce anything except proper nouns, numbers, and dates",
    "- When attribution is needed, use indirect speech: 'as the source notes…',",
    "  'X stated that…' rather than verbatim quotation",
    "",
    `TASK: ${task}`,
    "",
    "[SOURCE]",
    sourceText,
  ].join("\n");
}

async function safeGeminiCall(
  client: GoogleGenerativeAI,
  modelId: string,
  sourceText: string,
  task: string
): Promise<string> {
  const model = client.getGenerativeModel({ model: modelId });
 
  const initial = await model.generateContent(`${task}\n\n${sourceText}`);
  let det = detectRecitation(initial.response);
  if (!det.isRecitation && det.partial) return det.partial;
 
  const paraphrasePrompt = buildParaphrasePrompt(sourceText, task);
  const second = await model.generateContent(paraphrasePrompt);
  det = detectRecitation(second.response);
  if (!det.isRecitation && det.partial) return det.partial;
 
  return chunkAndAggregate(model, sourceText, task);
}
 
async function chunkAndAggregate(model: any, source: string, task: string): Promise<string> {
  const chunks = splitIntoChunks(source, 3000);
  const summaries: string[] = [];
  for (const chunk of chunks) {
    const prompt = buildParaphrasePrompt(chunk, "extract the three main points of this fragment");
    const r = await model.generateContent(prompt);
    const d = detectRecitation(r.response);
    if (d.partial) summaries.push(d.partial);
  }
  const integration = buildParaphrasePrompt(summaries.join("\n---\n"), task);
  const final = await model.generateContent(integration);
  return detectRecitation(final.response).partial;
}
 
function splitIntoChunks(text: string, size: number): string[] {
  const chunks: string[] = [];
  for (let i = 0; i < text.length; i += size) {
    chunks.push(text.slice(i, i + size));
  }
  return chunks;
}

interface SanitizationResult {
  sanitized: string;
  flags: string[];
}
 
function sanitizeSource(source: string): SanitizationResult {
  const flags: string[] = [];
  let s = source;
 
  // Long quote blocks (more than 30 words inside quotation marks) are risk-prone
  s = s.replace(/"[^"]{60,}"/g, (match) => {
    flags.push("long-quote-truncated");
    return match.slice(0, 30) + "…[truncated]…" + match.slice(-30);
  });
 
  // URLs sometimes get treated as quotation triggers; strip to domain
  s = s.replace(/https?:\/\/([\w.-]+)[^\s]*/g, (_match, host) => `[${host}]`);
 
  return { sanitized: s, flags };
}

const MODEL_FALLBACK_CHAIN = [
  "gemini-3-2-pro",
  "gemini-2-5-pro",
  "gemini-2-5-flash",
] as const;
 
async function modelFallback(
  client: GoogleGenerativeAI,
  sourceText: string,
  task: string
): Promise<string> {
  for (const modelId of MODEL_FALLBACK_CHAIN) {
    try {
      const result = await safeGeminiCall(client, modelId, sourceText, task);
      if (result) return result;
    } catch (err) {
      // continue to next model
    }
  }
  throw new Error("all models blocked by recitation");
}