@noobdemon/noob-cli 1.5.2 → 1.5.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noobdemon/noob-cli",
-  "version": "1.5.2",
+  "version": "1.5.4",
   "publishConfig": {
     "access": "public"
   },

package/src/agent.js

@@ -175,24 +175,48 @@ function buildPrompt(history) {
 }
 
 // Extract a single tool call from an assistant message, if present.
+// NOTE: we do NOT match up to a closing ``` fence — write_file content routinely
+// contains its own ```code``` fences (e.g. a README), and the first inner fence
+// would close the block early and break the JSON. Instead, find the ```tool (or
+// ```json) opener and brace-match the first balanced JSON object after it.
 export function parseToolCall(text) {
-  // Preferred: ```tool { ... } ```
-  let m = text.match(/```tool\s*\n([\s\S]*?)```/);
-  // Fallback: a ```json block that contains a "name" field.
-  if (!m) {
-    const j = text.match(/```json\s*\n([\s\S]*?)```/);
-    if (j && /"name"\s*:/.test(j[1])) m = j;
-  }
-  if (!m) return null;
-  try {
-    const obj = JSON.parse(m[1].trim());
+  for (const fence of ["tool", "json"]) {
+    const open = text.match(new RegExp("```" + fence + "[ \\t]*\\n"));
+    if (!open) continue;
+    const obj = extractJsonObject(text, open.index + open[0].length);
     if (obj && typeof obj.name === "string") return { name: obj.name, input: obj.input || {} };
-  } catch {
-    /* malformed — treat as prose */
   }
   return null;
 }
 
+// Parse the first balanced {…} at/after `from`, tracking string literals and
+// escapes so braces or backticks INSIDE string values don't throw off the depth
+// count. Returns the parsed object, or null if malformed/truncated (unbalanced).
+function extractJsonObject(s, from) {
+  const start = s.indexOf("{", from);
+  if (start === -1) return null;
+  let depth = 0, inStr = false, esc = false;
+  for (let i = start; i < s.length; i++) {
+    const ch = s[i];
+    if (inStr) {
+      if (esc) esc = false;
+      else if (ch === "\\") esc = true;
+      else if (ch === '"') inStr = false;
+      continue;
+    }
+    if (ch === '"') inStr = true;
+    else if (ch === "{") depth++;
+    else if (ch === "}" && --depth === 0) {
+      try {
+        return JSON.parse(s.slice(start, i + 1));
+      } catch {
+        return null; // malformed JSON — treat as prose
+      }
+    }
+  }
+  return null; // unbalanced (e.g. stream cut mid-block) — auto-continue finishes it
+}
+
 /**
  * Run one agent turn (which may span several tool steps).
  *

package/src/api.js

@@ -41,10 +41,59 @@ async function parseError(resp) {
 
 /**
  * Stream a chat/merge/search request from the gateway.
+ *
+ * Auto-continue (chat only): the chat upstream runs on Vercel, which kills the
+ * function at ~300s. A long reply gets cut mid-stream — the gateway flags this
+ * with `{truncated:true}` (or the connection just drops with no `{done}`). When
+ * that happens we re-send the SAME transcript plus the partial reply so far and
+ * ask the model to write ONLY the rest, then append it. The caller sees one
+ * seamless stream. Capped by `maxContinues` so a genuinely broken upstream can't
+ * loop forever.
+ *
  * @returns {Promise<{text:string, reasoning:string}>}
  */
-export async function stream({ mode = "chat", message, model, signal, onDelta, onReasoning, onStatus, idleMs = 120000 }) {
+export async function stream({ mode = "chat", message, model, signal, onDelta, onReasoning, onStatus, idleMs = 120000, maxContinues = 6 }) {
   const endpoint = mode === "search" ? "/api/search" : mode === "merge" ? "/api/merge" : "/api/chat";
+
+  let fullText = "";
+  let reasoning = "";
+  let prompt = message; // prompt gửi đi: lần đầu = nguyên bản, các lần sau = nối tiếp
+
+  for (let attempt = 0; ; attempt++) {
+    const r = await streamOnce({ endpoint, mode, message: prompt, model, signal, idleMs, onStatus, onDelta, onReasoning });
+    fullText = mode === "chat" ? fullText + r.text : r.text; // chat: ghép các đoạn nối tiếp; mode khác: thay thế
+    if (r.reasoning) reasoning = r.reasoning;
+
+    // Còn nối tiếp được không? Chỉ với chat, khi bị cắt, còn lượt, và lần này có
+    // ra chữ thật (đoạn rỗng → coi như xong, tránh lặp vô tận).
+    if (!r.truncated || mode !== "chat" || attempt >= maxContinues || !r.text.trim()) break;
+    prompt = continuationPrompt(message, fullText);
+  }
+
+  return { text: fullText.trim(), reasoning: reasoning.trim() };
+}
+
+// Dựng prompt "nối tiếp" khi câu trả lời bị cắt giữa chừng: gửi lại nguyên ngữ
+// cảnh gốc + phần model đã viết dở + yêu cầu viết TIẾP đúng chỗ dừng, không lặp.
+function continuationPrompt(message, partial) {
+  const bar = "=".repeat(60);
+  return (
+    message +
+    "\n\n" + bar +
+    "\n## ASSISTANT (bị ngắt giữa chừng — phần trả lời dưới đây CHƯA hoàn tất)\n" +
+    partial +
+    "\n\n" + bar +
+    "\n# SYSTEM: Phần trả lời ngay trên bị mạng/timeout cắt ngang trước khi xong. " +
+    "Hãy VIẾT TIẾP liền mạch từ ĐÚNG ký tự cuối cùng ở trên — KHÔNG lặp lại hay diễn đạt lại bất kỳ chữ nào đã hiện, KHÔNG mở đầu lại, KHÔNG thêm lời dẫn. " +
+    "Chỉ xuất phần CÒN LẠI. Nếu đang viết dở một khối tool thì hoàn tất đúng khối đó. Nếu thật ra đã xong, chỉ xuất một dấu cách rồi dừng."
+  );
+}
+
+/**
+ * One network attempt of the stream. Returns this attempt's accumulated text +
+ * a `truncated` flag telling the caller whether the reply was cut short.
+ */
+async function streamOnce({ endpoint, mode, message, model, signal, idleMs, onStatus, onDelta, onReasoning }) {
   const body = mode === "search" ? { query: message } : mode === "merge" ? { message } : { message, model };
 
   // Idle-timeout: nếu KHÔNG nhận được byte nào trong idleMs (kết nối treo), tự
@@ -65,6 +114,8 @@ export async function stream({ mode = "chat", message, model, signal, onDelta, o
 
   let text = "";
   let reasoning = "";
+  let sawDone = false; // thấy {done} = stream kết thúc tử tế (không bị cắt)
+  let truncated = false; // gateway báo upstream bị cắt giữa chừng (Vercel 300s)
 
   // Một dòng SSE → cập nhật text/reasoning. Tách ra để dùng lại khi flush dòng cuối.
   const processLine = (rawLine) => {
@@ -88,6 +139,8 @@ export async function stream({ mode = "chat", message, model, signal, onDelta, o
       onReasoning?.(p.reasoning);
       if (p.answer) text = p.answer;
     }
+    if (p.truncated) truncated = true;
+    if (p.done) sawDone = true;
     if (p.error) throw new ApiError(p.error, {});
   };
 
@@ -118,9 +171,17 @@ export async function stream({ mode = "chat", message, model, signal, onDelta, o
     buf += decoder.decode(); // flush decoder
     if (buf.trim()) processLine(buf); // dòng SSE cuối không có '\n' — đừng bỏ sót
 
-    return { text: text.trim(), reasoning: reasoning.trim() };
+    // Chat: gateway gửi {done} khi xong sạch. Stream EOF mà chưa thấy {done} dù
+    // đã có chữ → kết nối/edge rớt giữa chừng → coi như bị cắt để nối tiếp.
+    if (mode === "chat" && !sawDone && text) truncated = true;
+
+    return { text, reasoning, truncated };
   } catch (err) {
+    if (signal?.aborted) throw err; // người dùng bấm Ctrl+C → huỷ thật, không nối tiếp
     if (timedOut) throw new ApiError("Kết nối tới máy chủ quá thời gian chờ (treo).", { code: "timeout" });
+    // Rớt mạng giữa chừng (không phải huỷ, không phải treo): với chat, nếu đã có
+    // chữ thì trả phần đã nhận + cờ truncated để lớp trên nối tiếp.
+    if (mode === "chat" && text) return { text, reasoning, truncated: true };
     throw err;
   } finally {
     clearTimeout(idle);