When using Gemini the translation does not work

[PatrickHuiskens]

What's happening?

When using Gemini 2.5 flash lite, it will return an error like

Lingo.dev: [Failed Files]

❌ locales/en-GB/translation.json (nl-NL → en-GB)

 Unexpected token 'O', "OK{"source"... is not valid JSON

My fix was adding this to the prompt: Return ONLY raw JSON. Do not include conversational filler, markdown formatting, or status messages like 'OK'.

Exact Reproduction Steps

1. Setup Lingo
2. "id": "google",
   "model": "gemini-2.5-flash-lite"
3. Run translations

Expected

Correct translations file

Actual

Lingo.dev: [Failed Files]

❌ locales/en-GB/translation.json (nl-NL → en-GB)

 Unexpected token 'O', "OK{"source"... is not valid JSON

Screenshots/Videos

[vrcprl]

hi @PatrickHuiskens - thanks for reporting. Team is taking a look!

[Aparnap2]

hi ,

i'd like to work on this.

---

Proposed Solution: Sanitize LLM Response Before JSON Parsing

Problem Analysis

The issue occurs in packages/cli/src/cli/localizer/explicit.ts at line 196 where the code directly attempts to parse the LLM response:

const result = JSON.parse(response.text);

When using "chatty" models like Gemini 2.5 Flash Lite, the response sometimes includes conversational prefixes like "OK", resulting in malformed JSON strings such as:

OK{"sourceLocale":"nl-NL",...}

This causes a parsing error: Unexpected token 'O', "OK{"source"... is not valid JSON

Root Cause

The current implementation assumes the LLM will always return clean JSON, but different models have varying tendencies to add conversational context despite the system prompt. While @PatrickHuiskens's workaround of adding explicit instructions to the prompt helps, it's not reliable across all models and all scenarios.

Proposed Fix

I propose sanitizing the response text before attempting JSON parsing. This makes the code resilient to model quirks without relying solely on prompt engineering.

Implementation

Modify the localize function in packages/cli/src/cli/localizer/explicit.ts (starting at line 190):

Current Code:

const response = await generateText({
  model,
  ...params.settings,
  messages: [
    { role: "system", content: systemPrompt },
    { role: "user", content: "OK" },
    ...shots.flatMap(
      ([userShot, assistantShot]) =>
        [
          { role: "user", content: JSON.stringify(userShot) },
          { role: "assistant", content: JSON.stringify(assistantShot) },
        ] as ModelMessage[],
    ),
    { role: "user", content: JSON.stringify(payload) },
  ],
});

const result = JSON.parse(response.text);

Proposed Code:

const response = await generateText({
  model,
  ...params.settings,
  messages: [
    { role: "system", content: systemPrompt },
    { role: "user", content: "OK" },
    ...shots.flatMap(
      ([userShot, assistantShot]) =>
        [
          { role: "user", content: JSON.stringify(userShot) },
          { role: "assistant", content: JSON.stringify(assistantShot) },
        ] as ModelMessage[],
    ),
    { role: "user", content: JSON.stringify(payload) },
  ],
});

// Sanitize response text to handle chatty model outputs
let text = response.text.trim();

// Remove common conversational prefixes
const conversationalPrefixes = ['OK', 'Sure', 'Here is', 'Here you go', 'Certainly'];
for (const prefix of conversationalPrefixes) {
  if (text.startsWith(prefix)) {
    text = text.substring(prefix.length).trim();
    // Remove any remaining punctuation/whitespace after prefix
    text = text.replace(/^[:\s,]+/, '');
    break;
  }
}

// Find the first '{' to handle any remaining non-JSON preamble
const firstBrace = text.indexOf('{');
if (firstBrace > 0) {
  text = text.substring(firstBrace);
}

// Find the last '}' to handle any JSON postamble
const lastBrace = text.lastIndexOf('}');
if (lastBrace !== -1 && lastBrace < text.length - 1) {
  text = text.substring(0, lastBrace + 1);
}

// Parse the cleaned JSON
let result;
try {
  result = JSON.parse(text);
} catch (parseError) {
  // Fallback: try jsonrepair if standard parsing fails
  try {
    const repaired = jsonrepair(text);
    result = JSON.parse(repaired);
  } catch (repairError) {
    throw new Error(
      `Failed to parse LLM response as JSON. Original text: ${response.text.substring(0, 200)}...`
    );
  }
}

Why This Approach?

1. Defense in depth: Handles multiple types of conversational additions (prefixes, postfixes, markdown formatting)
2. Preserves existing fallback: The jsonrepair logic is still available as a secondary fallback
3. Better error messages: If all parsing attempts fail, users get a more informative error showing the actual response
4. Model-agnostic: Works with any chatty model, not just Gemini
5. Backward compatible: Doesn't break existing behavior for well-behaved models

Testing

To verify this fix, test with:

• Gemini 2.5 Flash Lite (as reported in this issue)
• Other providers (OpenAI, Anthropic, etc.) to ensure no regression
• Edge cases like responses with markdown code blocks: ```json\n{...}\n```

Alternative Considered

While adding prompt instructions (as suggested by @PatrickHuiskens) helps, it's not guaranteed to work 100% of the time because:

• Different models interpret prompts differently
• System prompts can be overridden by model fine-tuning
• It doesn't protect against future model updates changing behavior

The code-based sanitization is more reliable and handles edge cases better.

---

[linear]

from maxprilutskiy:

Hi all!

Overall looks good, here are my thoughts.

1. indexOf - ok, looks reasonable
2. The below code:

const conversationalPrefixes = ['OK', 'Sure', 'Here is', 'Here you go', 'Certainly'];

^ looks pretty bad, is it's undeterministic, potentially flaky, hence will be hard to debug

3. jsonrepair is a good suggestion as well

So, as long as #2 is excluded, this is ready to be worked on! cc @vrcprl

cc @PatrickHuiskens @Aparnap2

[Aparnap2]

---

@maxprilutskiy Thanks for the feedback! I agree that hardcoding conversational prefixes is brittle and nondeterministic.

I will proceed with the implementation that relies strictly on structural extraction (indexOf/lastIndexOf) and jsonrepair. This approach is deterministic and should handle Gemini's "OK" prefixes (as well as other conversational wrappers) without needing to guess specific strings.

Revised Implementation Plan

I will modify packages/cli/src/cli/localizer/explicit.ts to:

1. Extract: Locate the potential JSON payload by finding the first { and last }.
2. Parse: Attempt to parse that substring natively.
3. Repair: Fallback to jsonrepair if the extraction alone isn't sufficient (e.g. malformed JSON internals).

The Logic:

// ... inside localize function ...

const response = await generateText({ ... });

let text = response.text;

// 1. Structural Extraction: Find the outer bounds of the JSON object
const firstBrace = text.indexOf('{');
const lastBrace = text.lastIndexOf('}');

// Only slice if valid braces are found in the correct order
if (firstBrace !== -1 && lastBrace !== -1 && lastBrace >= firstBrace) {
  text = text.substring(firstBrace, lastBrace + 1);
}

let result;
try {
  // 2. Fast path: standard parse
  result = JSON.parse(text);
} catch (e) {
  // 3. Robust fallback: repair malformed JSON
  try {
    const repaired = jsonrepair(text);
    result = JSON.parse(repaired);
  } catch (err) {
     throw new Error(`Failed to parse response: ${response.text.substring(0, 200)}...`);
  }
}

I will start working on the PR then.

[Aparnap2]

@maxprilutskiy @vrcprl I'd like to work on this issue. Based on the feedback, I will implement the solution using indexOf/lastIndexOf for structural JSON extraction with jsonrepair as fallback, avoiding the hardcoded prefix list.

My implementation plan:

1. Extract JSON using indexOf('{') and lastIndexOf('}')
2. Try native JSON.parse() first
3. Fallback to jsonrepair if parsing fails
4. Add comprehensive error messages
5. Include unit tests for the fix

May I be assigned to this issue?

[vrcprl]

assigning to you @Aparnap2