feat: improve JSON parsing and error handling by introducing isLikelyTruncatedJson function to detect incomplete JSON responses. Update client logic to handle truncation retries more effectively and enhance error messaging for truncated responses. Add tests to validate new functionality and ensure robust error reporting.

packages/ai/src/__tests__/parse-response.test.ts

@@ -1,6 +1,7 @@
 import { describe, expect, it } from "bun:test";
 import {
   extractContentFromCompletionBody,
+  isLikelyTruncatedJson,
   parseAiJsonResponse,
   stripReasoningBlocks,
 } from "../parse-response";
@@ -47,6 +48,13 @@ describe("parseAiJsonResponse", () => {
       "Empty response from AI",
     );
   });
+
+  it("detects truncated JSON and throws a clear truncation error", () => {
+    const truncated =
+      '{"title":"The Global Rise of Coffee Culture","passage":"Coffee has a rich history in the highl';
+    expect(isLikelyTruncatedJson(truncated)).toBe(true);
+    expect(() => parseAiJsonResponse(truncated)).toThrow("JSON response was truncated");
+  });
 });
 
 describe("extractContentFromCompletionBody", () => {

packages/ai/src/agentic.ts

@@ -53,7 +53,7 @@ function calculateMaxTokens(
   const base = userMax > 0 ? userMax : 16_384;
   switch (step) {
     case "passage":
-      return Math.min(base, 8_192);
+      return Math.min(Math.max(base, 6_000), 16_384);
     case "validate":
       return Math.min(base, 4_096);
     case "self_validate":

packages/ai/src/client.ts

@@ -1,5 +1,6 @@
 import {
   extractContentFromCompletionBody,
+  isLikelyTruncatedJson,
   looksLikeHtmlErrorPage,
   stripReasoningBlocks,
 } from "./parse-response";
@@ -117,22 +118,7 @@ async function readSSEStream(
   return { content: fullContent, usage: lastUsage, rawBody };
 }
 
-function looksTruncated(content: string): boolean {
-  const trimmed = content.trim();
-  if (trimmed.length === 0) return false;
-  // JSON object/array should end with } or ]
-  const lastChar = trimmed[trimmed.length - 1];
-  if (lastChar === "}" || lastChar === "]") return false;
-  // Check for common truncation signatures
-  const unterminated = /Unterminated string|Unexpected end of JSON|Unexpected (token|EOF)|Expected ('.*'|".*")/i;
-  try {
-    JSON.parse(trimmed);
-    return false;
-  } catch (err: any) {
-    if (unterminated.test(err.message)) return true;
-  }
-  return false;
-}
+const MAX_TRUNCATION_RETRIES = 2;
 
 function isResponseFormatError(status: number, text: string): boolean {
   if (status !== 400 && status !== 422) return false;
@@ -186,7 +172,11 @@ export class OpenAICompatibleClient {
   private async _doChatCompletion(
     opts: ChatCompletionOptions,
     callbacks: StreamCallbacks | undefined,
-    ctx: { attempt: number; retriedForTruncation?: boolean; retriedForResponseFormat?: boolean },
+    ctx: {
+      attempt: number;
+      truncationRetries?: number;
+      retriedForResponseFormat?: boolean;
+    },
   ): Promise<ChatCompletionResult> {
     let hostname: string;
     try {
@@ -299,20 +289,21 @@ export class OpenAICompatibleClient {
       throw new Error("Empty response from AI");
     }
 
-    // Truncation detection + retry
-    if (!ctx.retriedForTruncation && looksTruncated(result.content)) {
-      const newMaxTokens = opts.max_tokens
-        ? Math.min(Math.round(opts.max_tokens * 1.5), 128_000)
-        : 16_384;
+    // Truncation detection + retry (incomplete JSON mid-stream)
+    const truncationRetries = ctx.truncationRetries ?? 0;
+    if (truncationRetries < MAX_TRUNCATION_RETRIES && isLikelyTruncatedJson(result.content)) {
+      const baseTokens = opts.max_tokens && opts.max_tokens > 0 ? opts.max_tokens : 8_192;
+      const newMaxTokens = Math.min(Math.round(baseTokens * 1.75), 128_000);
       log("warn", "Response looks truncated, retrying with more tokens", {
         originalLength: result.content.length,
         originalMaxTokens: opts.max_tokens,
         newMaxTokens,
+        truncationRetry: truncationRetries + 1,
       });
       return this._doChatCompletion(
         { ...opts, max_tokens: newMaxTokens },
         callbacks,
-        { ...ctx, attempt: ctx.attempt + 1, retriedForTruncation: true },
+        { ...ctx, attempt: ctx.attempt + 1, truncationRetries: truncationRetries + 1 },
       );
     }
 

packages/ai/src/parse-response.ts

@@ -29,6 +29,36 @@ export function stripReasoningBlocks(content: string): string {
   return text.trim();
 }
 
+const TRUNCATED_JSON_ERROR = "JSON response was truncated";
+
+/** Detect incomplete JSON — valid start but stream/token limit cut off before closing braces. */
+export function isLikelyTruncatedJson(content: string): boolean {
+  const trimmed = stripReasoningBlocks(content).trim();
+  if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) return false;
+
+  if (trimmed.endsWith("}") || trimmed.endsWith("]")) {
+    try {
+      JSON.parse(trimmed);
+      return false;
+    } catch (err: unknown) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return /unterminated string|unexpected eof|unexpected end|expected .* at end/i.test(msg);
+    }
+  }
+
+  try {
+    JSON.parse(trimmed);
+    return false;
+  } catch (err: unknown) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (/unterminated string|unexpected eof|unexpected end|expected .* at end/i.test(msg)) {
+      return true;
+    }
+  }
+
+  return true;
+}
+
 function extractJsonCandidate(content: string): string {
   const trimmed = content.trim();
   const fenced = trimmed.match(/```(?:json)?\s*([\s\S]*?)```/i);
@@ -78,11 +108,19 @@ export function parseAiJsonResponse(content: string): unknown {
     }
   }
 
+  if (isLikelyTruncatedJson(normalized)) {
+    throw new Error(
+      `${TRUNCATED_JSON_ERROR} before completion (usually max_tokens too low). Preview: ${normalized.slice(0, 200)}`,
+    );
+  }
+
   throw new Error(
     `Failed to parse AI response as JSON: ${lastError?.message ?? "unknown error"}. Preview: ${normalized.slice(0, 200)}`,
   );
 }
 
+export { TRUNCATED_JSON_ERROR };
+
 export function extractContentFromCompletionBody(body: string): string | null {
   const trimmed = body.trim();
   if (!trimmed.startsWith("{")) return null;

packages/api/src/__tests__/generation-outcome.test.ts

@@ -68,6 +68,15 @@ describe("resolveGenerationJobOutcome", () => {
     expect(outcome.errorMessage).not.toContain("Periksa model/API provider");
   });
 
+  it("labels truncated JSON with actionable guidance", () => {
+    const message = formatGenerationErrorMessage({
+      cause: "JSON response was truncated before completion (usually max_tokens too low). Preview: {\"title\":",
+      failedSections: ["READING"],
+    });
+    expect(message).toContain("terpotong");
+    expect(message).toContain("Max Tokens");
+  });
+
   it("surfaces JSON parse cause instead of generic provider hint", () => {
     const outcome = resolveGenerationJobOutcome({
       requestedCount: 5,

packages/api/src/lib/generation-outcome.ts

@@ -46,6 +46,13 @@ export function formatGenerationErrorMessage(input: {
     return `Model reasoning tidak kompatibel dengan parser Labas.${hint} Coba non-reasoning model, atau update server ke versi terbaru.`;
   }
 
+  if (
+    lower.includes("json response was truncated") ||
+    lower.includes("unterminated string")
+  ) {
+    return `Respons model terpotong sebelum JSON selesai (biasanya max tokens terlalu kecil).${hint} Naikkan Max Tokens di Settings atau kurangi jumlah soal/format.`;
+  }
+
   if (lower.includes("failed to parse ai response") || lower.includes("invalid json response")) {
     return `Model merespons, tapi output tidak valid JSON.${hint} ${truncate(cause, 280)}`;
   }