@ykurilov/agent-chat-core 0.58.0 → 0.59.0

package/dist/{chunk-KAG3QTZC.js → chunk-QA5DVEXF.js}

@@ -1853,6 +1853,494 @@ function createBurstWaits() {
   };
 }
 
+// src/agent-run/forged-blocks.ts
+import { wrapLanguageModel as wrapLanguageModel2 } from "ai";
+
+// src/text/markdown-code.ts
+function codeFenceOf(line) {
+  return /^ {0,3}(`{3,}|~{3,})/.exec(line)?.[1] ?? null;
+}
+function closesCodeFence(line, fence) {
+  const opener = codeFenceOf(line);
+  return opener !== null && opener[0] === fence[0] && opener.length >= fence.length && line.trim() === opener;
+}
+function isIndentedCodeOrQuote(line) {
+  return /^(?: {4}|\t)/.test(line) || /^\s*>/.test(line);
+}
+
+// src/agent-run/length-cut.ts
+var LENGTH_CUT_PART_TYPE = "data-length-cut";
+var LENGTH_CUT_NOTE = "[\u041E\u0442\u0432\u0435\u0442 \u043E\u0431\u043E\u0440\u0432\u0430\u043D: \u043C\u043E\u0434\u0435\u043B\u044C \u0443\u043F\u0451\u0440\u043B\u0430\u0441\u044C \u0432 \u043F\u0440\u0435\u0434\u0435\u043B \u0434\u043B\u0438\u043D\u044B \u043E\u0442\u0432\u0435\u0442\u0430]";
+function lengthCutForModel(part) {
+  return part.type === LENGTH_CUT_PART_TYPE ? { type: "text", text: LENGTH_CUT_NOTE } : void 0;
+}
+
+// src/agent-run/unanswered-messages.ts
+var UNANSWERED_NOTE = "[\u041E\u0442\u0432\u0435\u0442\u0430 \u043D\u0430 \u044D\u0442\u043E \u0441\u043E\u043E\u0431\u0449\u0435\u043D\u0438\u0435 \u043D\u0435\u0442: \u0445\u043E\u0434 \u043E\u0431\u043E\u0440\u0432\u0430\u043B\u0441\u044F \u0434\u043E \u043F\u0435\u0440\u0432\u044B\u0445 \u0441\u043B\u043E\u0432]";
+function withUnansweredMarked(messages) {
+  return messages.flatMap(
+    (message, index) => message.role === "user" && messages[index - 1]?.role === "user" ? [{ role: "assistant", content: [{ type: "text", text: UNANSWERED_NOTE }] }, message] : [message]
+  );
+}
+
+// src/agent-run/forged-blocks.ts
+var CHANNEL_NOTE_LINES = [
+  "\u0420\u0430\u0437\u0433\u043E\u0432\u043E\u0440 \u0441\u043D\u043E\u0432\u0430 \u0432 \u0432\u0435\u0431-\u043F\u0440\u0438\u043B\u043E\u0436\u0435\u043D\u0438\u0438: \u043E\u0431\u044B\u0447\u043D\u0430\u044F \u0440\u0430\u0437\u043C\u0435\u0442\u043A\u0430 \u0438 \u0438\u043D\u0441\u0442\u0440\u0443\u043C\u0435\u043D\u0442\u044B \u0441\u0442\u0440\u0430\u043D\u0438\u0446\u044B \u0434\u043E\u0441\u0442\u0443\u043F\u043D\u044B.",
+  "\u0420\u0430\u0437\u0433\u043E\u0432\u043E\u0440 \u0438\u0434\u0451\u0442 \u0432 Telegram. \u041F\u0438\u0448\u0438 \u043E\u0431\u044B\u0447\u043D\u044B\u043C Markdown: \u0435\u0433\u043E \u043F\u0435\u0440\u0435\u0432\u0435\u0434\u0443\u0442 \u0432 \u0440\u0430\u0437\u043C\u0435\u0442\u043A\u0443 Telegram. \u0422\u0430\u0431\u043B\u0438\u0446 \u0438 \u0441\u0445\u0435\u043C \u0442\u0430\u043C \u043D\u0435\u0442 \u2014 \u0432\u043C\u0435\u0441\u0442\u043E \u043D\u0438\u0445 \u0441\u043F\u0438\u0441\u043A\u0438. \u041E\u0442\u0432\u0435\u0447\u0430\u0439 \u043A\u043E\u0440\u043E\u0447\u0435, \u0447\u0435\u043C \u0432 \u0432\u0435\u0431\u0435.",
+  "\u0420\u0430\u0437\u0433\u043E\u0432\u043E\u0440 \u0438\u0434\u0451\u0442 \u0432\u043E \u0412\u041A\u043E\u043D\u0442\u0430\u043A\u0442\u0435. \u0420\u0430\u0437\u043C\u0435\u0442\u043A\u0438 \u0442\u0430\u043C \u043D\u0435\u0442: Markdown \u043F\u0440\u0435\u0432\u0440\u0430\u0442\u0438\u0442\u0441\u044F \u0432 \u043F\u0440\u043E\u0441\u0442\u043E\u0439 \u0442\u0435\u043A\u0441\u0442. \u041F\u0438\u0448\u0438 \u043F\u0440\u043E\u0441\u0442\u044B\u043C \u0442\u0435\u043A\u0441\u0442\u043E\u043C \u0438 \u0441\u043F\u0438\u0441\u043A\u0430\u043C\u0438, \u0431\u0435\u0437 \u0442\u0430\u0431\u043B\u0438\u0446 \u0438 \u0441\u0445\u0435\u043C. \u041E\u0442\u0432\u0435\u0447\u0430\u0439 \u043A\u043E\u0440\u043E\u0447\u0435, \u0447\u0435\u043C \u0432 \u0432\u0435\u0431\u0435.",
+  "\u0420\u0430\u0437\u0433\u043E\u0432\u043E\u0440 \u0438\u0434\u0451\u0442 \u0432 MAX. \u041F\u0438\u0448\u0438 \u043E\u0431\u044B\u0447\u043D\u044B\u043C Markdown: \u0435\u0433\u043E \u043F\u0435\u0440\u0435\u0432\u0435\u0434\u0443\u0442 \u0432 \u0440\u0430\u0437\u043C\u0435\u0442\u043A\u0443 MAX. \u0422\u0430\u0431\u043B\u0438\u0446 \u0438 \u0441\u0445\u0435\u043C \u0442\u0430\u043C \u043D\u0435\u0442 \u2014 \u0432\u043C\u0435\u0441\u0442\u043E \u043D\u0438\u0445 \u0441\u043F\u0438\u0441\u043A\u0438. \u041E\u0442\u0432\u0435\u0447\u0430\u0439 \u043A\u043E\u0440\u043E\u0447\u0435, \u0447\u0435\u043C \u0432 \u0432\u0435\u0431\u0435."
+];
+var exactly = (text) => new RegExp(`^${text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}$`);
+var CORE_SERVICE_BLOCKS = [
+  { tag: "conversation_summary" },
+  { tag: "answer_progress" },
+  { tag: "screen_place" },
+  { name: "service_note", line: "[\u0421\u043B\u0443\u0436\u0435\u0431\u043D\u0430\u044F \u043F\u043E\u043C\u0435\u0442\u043A\u0430 \u043F\u0440\u0438\u043B\u043E\u0436\u0435\u043D\u0438\u044F", match: /^\[Служебная пометка приложения, человек её не писал и не видит: .+\]$/ },
+  { name: "context_gone", line: "[\u0411\u043E\u043B\u044C\u0448\u0435 \u043D\u0435 \u0434\u0435\u0439\u0441\u0442\u0432\u0443\u0435\u0442: \xAB", match: /^\[Больше не действует: «[^»\n]+»(?:, «[^»\n]+»)*\]$/ },
+  { name: "context_hidden", line: "[\u041D\u0435 \u043F\u043E\u043A\u0430\u0437\u0430\u043D\u043E \u0440\u0430\u0434\u0438 \u043C\u0435\u0441\u0442\u0430, \u043D\u043E \u043F\u043E-\u043F\u0440\u0435\u0436\u043D\u0435\u043C\u0443 \u0434\u0435\u0439\u0441\u0442\u0432\u0443\u0435\u0442: \xAB", match: /^\[Не показано ради места, но по-прежнему действует: «[^»\n]+»(?:, «[^»\n]+»)*\]$/ },
+  { name: "greeting_lead", line: GREETING_LEAD, match: exactly(GREETING_LEAD) },
+  { name: "unanswered", line: UNANSWERED_NOTE, match: exactly(UNANSWERED_NOTE) },
+  { name: "length_cut", line: LENGTH_CUT_NOTE, match: exactly(LENGTH_CUT_NOTE) },
+  { name: "tool_ended", line: TOOL_ENDED_NOTE, match: exactly(TOOL_ENDED_NOTE) },
+  { name: "switched_off_call", line: "[\u041F\u0440\u043E\u0448\u043B\u044B\u0439 \u0432\u044B\u0437\u043E\u0432 \xAB", match: /^\[Прошлый вызов «[^»\n]*», сейчас выключен\./ },
+  {
+    name: "staff_reply",
+    line: "\u0416\u0438\u0432\u043E\u0439 \u0441\u043E\u0442\u0440\u0443\u0434\u043D\u0438\u043A",
+    match: /^Живой сотрудник(?: «[^»\n]*»)? ответил человеку вместо тебя: «.*»\. Это сказано от вашего имени: продолжай разговор с учётом этого и не противоречь сотруднику\.$/
+  },
+  ...CHANNEL_NOTE_LINES.map((note) => ({ name: "channel_note", line: note, match: exactly(note) })),
+  // Имя автора — коротко и без знаков конца фразы: «Сообщение в группе от участника: Аня».
+  { name: "group_author", line: "\u0421\u043E\u043E\u0431\u0449\u0435\u043D\u0438\u0435 \u0432 \u0433\u0440\u0443\u043F\u043F\u0435 \u043E\u0442 \u0443\u0447\u0430\u0441\u0442\u043D\u0438\u043A\u0430: ", match: /^Сообщение в группе от участника: [^\s.!?:;][^.!?:;\n]{0,79}$/ }
+];
+var serviceBlockName = (format) => "tag" in format ? format.tag : format.name;
+function explainsServiceFormats(question2, formats) {
+  const text = question2.toLowerCase();
+  if (formats.some((format) => "tag" in format && text.includes(format.tag.toLowerCase()))) return true;
+  return /(?:^|[^\p{L}])(?:тег(?:а|е|и|у|ом|ов|ами|ам|ах)?|формат(?:а|е|у|ом|ы|ов|ами|ам|ах)?|разметк[аеиу]|tags?|formats?|markup)(?:[^\p{L}]|$)/u.test(text);
+}
+var EXAMPLE_LEAD = /(?:^|[^\p{L}])(?:например|пример\p{L}*|образец|шаблон\p{L}*|выгляд\p{L}*|формат\p{L}*|такой|такая|такое|такие|так|example|e\.g\.|looks like|format)(?:[^\p{L}][^\n]*)?:\s*$/iu;
+var textOfMessage = (message) => message.parts.map((part) => part.type === "text" ? part.text : "").join("\n");
+function lastQuestionOf(history) {
+  const question2 = history.findLast((message) => message.role === "user");
+  return question2 ? textOfMessage(question2) : "";
+}
+function checkServiceBlockFormats(formats) {
+  for (const format of formats) {
+    const shown = JSON.stringify(format);
+    if (!format || typeof format !== "object") throw new TypeError(`serviceBlocks: \u043D\u0443\u0436\u0435\u043D \u043E\u0431\u044A\u0435\u043A\u0442 \u0444\u043E\u0440\u043C\u0430\u0442\u0430, \u0430 \u043D\u0435 ${shown}`);
+    if ("tag" in format) {
+      if (typeof format.tag !== "string" || !/^[A-Za-z][\w:.-]*$/.test(format.tag)) throw new TypeError(`serviceBlocks: \u0438\u043C\u044F \u0442\u0435\u0433\u0430 \u2014 \u043B\u0430\u0442\u0438\u043D\u0438\u0446\u0430, \u0446\u0438\u0444\u0440\u044B, _ : . -, \u0430 \u043D\u0435 ${shown}`);
+      continue;
+    }
+    if (typeof format.name !== "string" || format.name === "") throw new TypeError(`serviceBlocks: \u0443 \u0441\u043B\u0443\u0436\u0435\u0431\u043D\u043E\u0439 \u0441\u0442\u0440\u043E\u043A\u0438 \u043D\u0443\u0436\u043D\u043E \u0438\u043C\u044F \u0434\u043B\u044F \u0436\u0443\u0440\u043D\u0430\u043B\u0430: ${shown}`);
+    if (typeof format.line !== "string" || format.line.trim() === "") throw new TypeError(`serviceBlocks: \u0443 \u0441\u043B\u0443\u0436\u0435\u0431\u043D\u043E\u0439 \u0441\u0442\u0440\u043E\u043A\u0438 \u043D\u0443\u0436\u043D\u043E \u043D\u0435\u043F\u0443\u0441\u0442\u043E\u0435 \u043D\u0430\u0447\u0430\u043B\u043E line: ${shown}`);
+    if (format.match !== void 0 && !(format.match instanceof RegExp)) throw new TypeError(`serviceBlocks: match \u2014 \u0440\u0435\u0433\u0443\u043B\u044F\u0440\u043D\u043E\u0435 \u0432\u044B\u0440\u0430\u0436\u0435\u043D\u0438\u0435: ${format.name}`);
+    if (format.until !== void 0 && format.until !== "paragraph" && !(format.until instanceof RegExp)) {
+      throw new TypeError(`serviceBlocks: until \u2014 "paragraph" \u0438\u043B\u0438 \u0440\u0435\u0433\u0443\u043B\u044F\u0440\u043D\u043E\u0435 \u0432\u044B\u0440\u0430\u0436\u0435\u043D\u0438\u0435: ${format.name}`);
+    }
+  }
+}
+var compiledByList = /* @__PURE__ */ new WeakMap();
+function compile(formats) {
+  const known = compiledByList.get(formats);
+  if (known) return known;
+  const tags = formats.flatMap((format) => "tag" in format ? [format.tag] : []);
+  const lines = formats.filter((format) => !("tag" in format));
+  const escape = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const starts = [...tags.map((tag) => `<\\/?${escape(tag)}`), ...lines.map((format) => escape(format.line))];
+  const hint = starts.length > 0 ? new RegExp(`(?:^|\\n) {0,3}(?:${starts.join("|")})`) : /(?!)/;
+  const compiled = { tags, lines, hint };
+  compiledByList.set(formats, compiled);
+  return compiled;
+}
+var MAX_ATTRIBUTES_LENGTH = 200;
+function paragraphEnd(text) {
+  const blank = /\n[ \t]*(?:\n|$)/g;
+  blank.lastIndex = Math.max(0, text.indexOf("\n"));
+  const found = text.indexOf("\n") < 0 ? null : blank.exec(text);
+  return found ? found.index + 1 : -1;
+}
+function createForgedBlockScanner(formats, options2 = {}) {
+  const compiled = compile(formats);
+  const lines = compiled.lines;
+  const tags = options2.explaining ? [] : compiled.tags;
+  let fence = null;
+  let previousLine = "";
+  let pending = "";
+  let ordinaryLine = null;
+  let block = null;
+  let skipSpace = false;
+  let out = [];
+  const emitText = (text) => {
+    if (!text) return;
+    const last = out.at(-1);
+    if (last?.kind === "text") last.text += text;
+    else out.push({ kind: "text", text });
+  };
+  const emitGap = (text) => {
+    const last = out.at(-1);
+    if (last?.kind === "gap") last.text += text;
+    else out.push({ kind: "gap", text });
+  };
+  const closeOrdinaryLine = (line) => {
+    if (line.trim() !== "") previousLine = line;
+    if (fence !== null) {
+      if (closesCodeFence(line, fence)) fence = null;
+    } else {
+      const opener = codeFenceOf(line);
+      if (opener) fence = opener;
+    }
+  };
+  function classify(line, complete) {
+    if (fence !== null || isIndentedCodeOrQuote(line) || codeFenceOf(line)) return "text";
+    const indent = /^ {0,3}/.exec(line)[0].length;
+    const body = line.slice(indent);
+    if (body === "") return complete ? "text" : "wait";
+    let waiting = false;
+    if (body[0] === "<") {
+      const closing = body[1] === "/";
+      const nameAt = closing ? 2 : 1;
+      for (const tag of tags) {
+        const head = body.slice(nameAt, nameAt + tag.length);
+        if (!tag.startsWith(head)) continue;
+        if (head.length < tag.length) {
+          waiting ||= body.length === nameAt + head.length;
+          continue;
+        }
+        if (closing) continue;
+        const next = body[nameAt + tag.length];
+        if (next === void 0) {
+          waiting = true;
+          continue;
+        }
+        if (next !== ">" && !/\s/.test(next)) continue;
+        const end = body.indexOf(">", nameAt + tag.length);
+        if (end >= 0 && end - (nameAt + tag.length) <= MAX_ATTRIBUTES_LENGTH && !body.slice(nameAt + tag.length, end).includes("\n")) {
+          if (EXAMPLE_LEAD.test(previousLine.trimEnd())) continue;
+          const close = `</${tag}>`;
+          const rest = body.slice(end + 1);
+          if (rest.includes(close)) return { kind: "tag", name: tag, close, from: indent + end + 1 };
+          if (!complete) {
+            waiting = true;
+            continue;
+          }
+          if (rest.trim() === "" || /^\s*[[{"]/.test(rest)) return { kind: "tag", name: tag, close, from: indent + end + 1 };
+          continue;
+        }
+        if (end < 0 && !complete && body.length - (nameAt + tag.length) <= MAX_ATTRIBUTES_LENGTH) waiting = true;
+      }
+    }
+    for (const format of lines) {
+      if (body.length < format.line.length) {
+        waiting ||= format.line.startsWith(body);
+        continue;
+      }
+      if (!body.startsWith(format.line)) continue;
+      if (!complete) {
+        waiting = true;
+        continue;
+      }
+      if (!format.match || format.match.test(body.trimEnd())) return { kind: "line", format };
+    }
+    return waiting && !complete ? "wait" : "text";
+  }
+  function openBlock(opener, line, newline) {
+    const whole = line + (newline ? "\n" : "");
+    if (opener.kind === "tag") {
+      block = { kind: "tag", name: opener.name, close: opener.close, text: whole, searchFrom: opener.from };
+      return;
+    }
+    const { format } = opener;
+    if (!format.until) {
+      out.push({ kind: "block", name: format.name, text: whole });
+      skipSpace = true;
+      return;
+    }
+    block = format.until === "paragraph" ? { kind: "paragraph", name: format.name, text: whole } : { kind: "until", name: format.name, until: format.until, text: whole };
+  }
+  function feedBlock(current, delta) {
+    current.text += delta;
+    if (current.kind === "tag") {
+      const at = current.text.indexOf(current.close, current.searchFrom);
+      if (at < 0) {
+        current.searchFrom = Math.max(current.searchFrom, current.text.length - current.close.length + 1);
+        return null;
+      }
+      const end = at + current.close.length;
+      return finishBlock(current, end);
+    }
+    let lineStart = current.text.indexOf("\n") + 1;
+    while (lineStart > 0) {
+      const lineEnd = current.text.indexOf("\n", lineStart);
+      if (lineEnd < 0) return null;
+      const line = current.text.slice(lineStart, lineEnd);
+      if (current.kind === "paragraph" && line.trim() === "") return finishBlock(current, lineStart);
+      if (current.kind === "until" && current.until.test(line.trim())) return finishBlock(current, lineEnd + 1);
+      lineStart = lineEnd + 1;
+    }
+    return null;
+  }
+  function finishBlock(current, end) {
+    out.push({ kind: "block", name: current.name, text: current.text.slice(0, end) });
+    block = null;
+    skipSpace = true;
+    previousLine = "";
+    return current.text.slice(end);
+  }
+  function feed(delta) {
+    let rest = delta;
+    while (rest) {
+      if (block) {
+        const left = feedBlock(block, rest);
+        if (left === null) return;
+        rest = left;
+        continue;
+      }
+      if (skipSpace) {
+        const space = /^\s*/.exec(rest)[0];
+        if (space) emitGap(space);
+        rest = rest.slice(space.length);
+        if (!rest) return;
+        skipSpace = false;
+        pending = "";
+        ordinaryLine = null;
+        continue;
+      }
+      if (ordinaryLine !== null) {
+        const newline2 = rest.indexOf("\n");
+        if (newline2 < 0) {
+          ordinaryLine += rest;
+          emitText(rest);
+          return;
+        }
+        closeOrdinaryLine(ordinaryLine + rest.slice(0, newline2));
+        emitText(rest.slice(0, newline2 + 1));
+        ordinaryLine = null;
+        rest = rest.slice(newline2 + 1);
+        continue;
+      }
+      const newline = rest.indexOf("\n");
+      const line = pending + (newline < 0 ? rest : rest.slice(0, newline));
+      const verdict = classify(line, newline >= 0);
+      if (verdict === "wait") {
+        pending = line;
+        return;
+      }
+      pending = "";
+      const after = newline < 0 ? "" : rest.slice(newline + 1);
+      if (verdict === "text") {
+        if (newline < 0) {
+          ordinaryLine = line;
+          emitText(line);
+          return;
+        }
+        closeOrdinaryLine(line);
+        emitText(`${line}
+`);
+        rest = after;
+        continue;
+      }
+      openBlock(verdict, line, newline >= 0);
+      rest = after;
+    }
+  }
+  const take = () => {
+    const pieces = out;
+    out = [];
+    return pieces;
+  };
+  return {
+    /** Следующий кусок текста → готовые куски. Начало возможного блока придерживается до следующего. */
+    push(delta) {
+      feed(delta);
+      return take();
+    },
+    /**
+     * Текст кончился: придержанное решается на неполной строке. Незакрытый тег — блок до первой пустой строки, остальное
+     * разбирается дальше; строчный блок — до конца текста.
+     */
+    end() {
+      for (; ; ) {
+        const current = block;
+        if (current) {
+          block = null;
+          const blank = current.kind === "tag" ? paragraphEnd(current.text) : -1;
+          if (blank < 0) {
+            out.push({ kind: "block", name: current.name, text: current.text });
+            continue;
+          }
+          finishBlock(current, blank);
+          feed(current.text.slice(blank));
+          continue;
+        }
+        if (!pending) break;
+        const line = pending;
+        pending = "";
+        const verdict = classify(line, true);
+        if (verdict === "text" || verdict === "wait") emitText(line);
+        else openBlock(verdict, line, false);
+      }
+      return take();
+    }
+  };
+}
+function cutForgedBlocks(text, formats, options2 = {}) {
+  if (!compile(formats).hint.test(text)) return { text, blocks: [] };
+  const scanner = createForgedBlockScanner(formats, options2);
+  const pieces = [...scanner.push(text), ...scanner.end()];
+  return {
+    text: pieces.map((piece) => piece.kind === "text" ? piece.text : "").join(""),
+    blocks: pieces.flatMap((piece) => piece.kind === "block" ? [piece.name] : [])
+  };
+}
+var hasWords = (text) => /[\p{L}\p{N}]/u.test(text);
+function cutForgedBlocksInParts(parts, formats, options2 = {}) {
+  const blocks = [];
+  const cleaned = parts.flatMap((part) => {
+    if (part.type !== "text") return [part];
+    const cut = cutForgedBlocks(part.text, formats, options2);
+    if (cut.blocks.length === 0) return [part];
+    blocks.push(...cut.blocks);
+    return cut.text.trim() === "" ? [] : [{ ...part, text: cut.text }];
+  });
+  if (blocks.length === 0) return null;
+  if (!cleaned.some((part) => part.type === "text" && hasWords(part.text))) return null;
+  return { parts: cleaned, blocks };
+}
+function withoutForgedBlocks(history, formats) {
+  let changed = false;
+  let question2 = "";
+  const cleaned = history.map((message) => {
+    if (message.role === "user") question2 = textOfMessage(message);
+    if (message.role !== "assistant") return message;
+    const cut = cutForgedBlocksInParts(message.parts, formats, { explaining: explainsServiceFormats(question2, formats) });
+    if (!cut) return message;
+    changed = true;
+    return { ...message, parts: cut.parts };
+  });
+  return changed ? cleaned : history;
+}
+function createForgedBlockGuard(formats) {
+  let worded = false;
+  let explaining = false;
+  const cut = [];
+  const kept = [];
+  const transformFor = () => {
+    const scanners = /* @__PURE__ */ new Map();
+    let held = null;
+    const starts = /* @__PURE__ */ new Map();
+    const started = /* @__PURE__ */ new Set();
+    const enqueue = (part, controller) => {
+      if (part.type === "text-start" && scanners.has(part.id)) {
+        starts.set(part.id, part);
+        return;
+      }
+      if (part.type === "text-delta" && !started.has(part.id) && starts.has(part.id)) {
+        controller.enqueue(starts.get(part.id));
+        started.add(part.id);
+      }
+      if (part.type === "text-end" && starts.has(part.id) && !started.has(part.id)) return;
+      controller.enqueue(part);
+    };
+    const isBlock = (item) => "name" in item && "text" in item && !("type" in item);
+    const settle = (keep, controller) => {
+      const items = held ?? [];
+      held = null;
+      for (const item of items) {
+        if (!isBlock(item)) enqueue(item, controller);
+        else {
+          if (keep) enqueue({ type: "text-delta", id: item.id, delta: item.text }, controller);
+          if (item.name) (keep ? kept : cut).push(item.name);
+        }
+      }
+    };
+    const send = (part, controller) => {
+      if (held) held.push(part);
+      else enqueue(part, controller);
+    };
+    const deltaOf = (id, pieces, controller) => {
+      let delta = "";
+      for (const piece of pieces) {
+        if (piece.kind === "text" && hasWords(piece.text)) {
+          worded = true;
+          if (held) settle(false, controller);
+        }
+        if (piece.kind === "text" && !held) delta += piece.text;
+        else if (worded) {
+          if (piece.kind === "block") cut.push(piece.name);
+        } else {
+          (held ??= []).push({ id, name: piece.kind === "block" ? piece.name : "", text: piece.text });
+        }
+      }
+      return delta;
+    };
+    const transform = (part, controller) => {
+      switch (part.type) {
+        case "text-start":
+          scanners.set(part.id, createForgedBlockScanner(formats, { explaining }));
+          break;
+        case "text-delta": {
+          const scanner = scanners.get(part.id);
+          if (!scanner) break;
+          const delta = deltaOf(part.id, scanner.push(part.delta), controller);
+          if (delta) send({ ...part, delta }, controller);
+          return;
+        }
+        case "text-end": {
+          const scanner = scanners.get(part.id);
+          if (!scanner) break;
+          scanners.delete(part.id);
+          const delta = deltaOf(part.id, scanner.end(), controller);
+          if (delta) send({ type: "text-delta", id: part.id, delta }, controller);
+          break;
+        }
+        case "tool-input-start":
+        case "tool-call":
+          if (held) settle(false, controller);
+          break;
+        case "finish":
+          if (held) settle(part.finishReason.unified !== "tool-calls", controller);
+          break;
+      }
+      send(part, controller);
+    };
+    const flush = (controller) => {
+      if (held) settle(true, controller);
+    };
+    return new TransformStream({ transform, flush });
+  };
+  return {
+    /**
+     * Новая попытка с последним вопросом человека: шаги прежней стёрты — слов у ответа снова нет. Вырезанное раньше
+     * остаётся в счёте для журнала.
+     */
+    reset(question2 = "") {
+      worded = false;
+      explaining = explainsServiceFormats(question2, formats);
+    },
+    /** Законченный текст мимо потока (переписка проверкой) — по тем же правилам, что поток этой попытки. */
+    cutText: (text) => cutForgedBlocks(text, formats, { explaining }),
+    /** Модель попытки под присмотром: каждый запрос — новый шаг. */
+    wrap(model) {
+      if (typeof model === "string" || formats.length === 0) return model;
+      return wrapLanguageModel2({
+        model,
+        middleware: {
+          specificationVersion: "v4",
+          wrapStream: async ({ doStream }) => {
+            const result = await doStream();
+            return { ...result, stream: result.stream.pipeThrough(transformFor()) };
+          }
+        }
+      });
+    },
+    /** Вырезанные блоки хода по порядку (имена) — для журнала. */
+    cutBlocks: () => cut,
+    /** Блоки, оставленные ради непустого ответа. */
+    keptBlocks: () => kept
+  };
+}
+
 // src/storage/chat-storage.ts
 var RELEASED_ANSWER_ALIVE_AT = (/* @__PURE__ */ new Date(0)).toISOString();
 function aliveAtByLocalClock(mark) {
@@ -2918,7 +3406,7 @@ function usageMinusJournaled(usage, journaled) {
 }
 
 // src/agent-run/build-model-request.ts
-import { convertToModelMessages, wrapLanguageModel as wrapLanguageModel4 } from "ai";
+import { convertToModelMessages, wrapLanguageModel as wrapLanguageModel5 } from "ai";
 
 // src/conversation/hanging-tool-calls.ts
 var PRELIMINARY_OUTPUT_MAX_LENGTH = 2e3;
@@ -3138,7 +3626,7 @@ ${chunk.delta}` } : chunk];
 }
 
 // src/agent-run/observe-model-calls.ts
-import { wrapLanguageModel as wrapLanguageModel2 } from "ai";
+import { wrapLanguageModel as wrapLanguageModel3 } from "ai";
 function observeModelCalls(model, context) {
   if (typeof model === "string") return model;
   const now = context.now ?? Date.now;
@@ -3148,7 +3636,7 @@ function observeModelCalls(model, context) {
     attempts.set(params.prompt, attempt);
     return attempt;
   };
-  return wrapLanguageModel2({
+  return wrapLanguageModel3({
     model,
     middleware: {
       specificationVersion: "v4",
@@ -3579,21 +4067,6 @@ function estimateMessagesTokens(messages) {
   }, 0);
 }
 
-// src/agent-run/length-cut.ts
-var LENGTH_CUT_PART_TYPE = "data-length-cut";
-var LENGTH_CUT_NOTE = "[\u041E\u0442\u0432\u0435\u0442 \u043E\u0431\u043E\u0440\u0432\u0430\u043D: \u043C\u043E\u0434\u0435\u043B\u044C \u0443\u043F\u0451\u0440\u043B\u0430\u0441\u044C \u0432 \u043F\u0440\u0435\u0434\u0435\u043B \u0434\u043B\u0438\u043D\u044B \u043E\u0442\u0432\u0435\u0442\u0430]";
-function lengthCutForModel(part) {
-  return part.type === LENGTH_CUT_PART_TYPE ? { type: "text", text: LENGTH_CUT_NOTE } : void 0;
-}
-
-// src/agent-run/unanswered-messages.ts
-var UNANSWERED_NOTE = "[\u041E\u0442\u0432\u0435\u0442\u0430 \u043D\u0430 \u044D\u0442\u043E \u0441\u043E\u043E\u0431\u0449\u0435\u043D\u0438\u0435 \u043D\u0435\u0442: \u0445\u043E\u0434 \u043E\u0431\u043E\u0440\u0432\u0430\u043B\u0441\u044F \u0434\u043E \u043F\u0435\u0440\u0432\u044B\u0445 \u0441\u043B\u043E\u0432]";
-function withUnansweredMarked(messages) {
-  return messages.flatMap(
-    (message, index) => message.role === "user" && messages[index - 1]?.role === "user" ? [{ role: "assistant", content: [{ type: "text", text: UNANSWERED_NOTE }] }, message] : [message]
-  );
-}
-
 // src/agent-run/staff-replies.ts
 function isStaffReply(message) {
   if (message.role !== "user") return false;
@@ -3751,7 +4224,7 @@ function withoutUndelivered(history) {
 }
 
 // src/agent-run/garbled-tail.ts
-import { wrapLanguageModel as wrapLanguageModel3 } from "ai";
+import { wrapLanguageModel as wrapLanguageModel4 } from "ai";
 var SIGN_ORDER = ["think", "role", "restart", "tool"];
 var TOKEN_SOURCE = String.raw`<\/?think>|<\|[^|\n<>]{1,40}\|>|<｜[^｜\n<>]{1,40}｜>`;
 var TEMPLATE_TOKEN = new RegExp(TOKEN_SOURCE, "g");
@@ -3923,7 +4396,7 @@ function createGarbledTailGuard() {
     /** Модель попытки под присмотром: каждый запрос — новый шаг. */
     wrap(model) {
       if (typeof model === "string") return model;
-      return wrapLanguageModel3({
+      return wrapLanguageModel4({
         model,
         middleware: {
           specificationVersion: "v4",
@@ -4028,16 +4501,16 @@ function visibleBefore(earlier, visible, offset) {
 function withoutCodeAndQuotes(text) {
   let fence = null;
   return text.split("\n").map((line) => {
-    const opener = /^ {0,3}(`{3,}|~{3,})/.exec(line)?.[1];
     if (fence !== null) {
-      if (opener && opener[0] === fence[0] && opener.length >= fence.length && line.trim() === opener) fence = null;
+      if (closesCodeFence(line, fence)) fence = null;
       return " ".repeat(line.length);
     }
+    const opener = codeFenceOf(line);
     if (opener) {
       fence = opener;
       return " ".repeat(line.length);
     }
-    if (/^(?: {4}|\t)/.test(line) || /^\s*>/.test(line)) return " ".repeat(line.length);
+    if (isIndentedCodeOrQuote(line)) return " ".repeat(line.length);
     return line.replace(/(`+)[^`\n]*?\1/g, (code) => " ".repeat(code.length));
   }).join("\n");
 }
@@ -4065,7 +4538,8 @@ async function buildModelRequest(input) {
     ...input.repeatSilence && { repeatSilence: input.repeatSilence }
   });
   const tools = input.tools ? sortToolsByName(input.tools) : void 0;
-  const sendable = input.switchableTools ? withSwitchedOffCallsAsText(sendableHistory(input.history), input.switchableTools, tools) : sendableHistory(input.history);
+  const cleaned = sendableHistory(input.serviceBlocks ? withoutForgedBlocks(input.history, input.serviceBlocks) : input.history);
+  const sendable = input.switchableTools ? withSwitchedOffCallsAsText(cleaned, input.switchableTools, tools) : cleaned;
   const noted = withStaffRepliesJoined(withChannelNotes(withModeNotes(withBurstsJoined(withCorrectionsJoined(sendable)), input.modeNotes)));
   const held = input.frozenContext ? holdNoteAfterApprovals(withFrozenContext(noted, input.frozenContext)) : { messages: noted };
   const history = selectReasoningForModel(held.messages, {
@@ -4150,7 +4624,7 @@ function withoutLoneSurrogatesDeep(value) {
 }
 function withRequestWatch(model, provider, watch) {
   if (!watch || typeof model === "string") return model;
-  return wrapLanguageModel4({
+  return wrapLanguageModel5({
     model,
     middleware: {
       specificationVersion: "v4",
@@ -4170,7 +4644,7 @@ function withRequestWatch(model, provider, watch) {
   });
 }
 function withTransientRetries(model, context) {
-  return typeof model === "string" ? model : wrapLanguageModel4({ model, middleware: createTransientRetryMiddleware(context) });
+  return typeof model === "string" ? model : wrapLanguageModel5({ model, middleware: createTransientRetryMiddleware(context) });
 }
 function withLastMessageMark(messages, options2) {
   if (!options2 || messages.length === 0) return messages;
@@ -5970,6 +6444,7 @@ async function runTurn(turnInput, emitRaw) {
   );
   const turnUsage = createTurnUsage();
   const garbledTail = createGarbledTailGuard();
+  const forgedBlocks = createForgedBlockGuard(turnInput.serviceBlocks ?? CORE_SERVICE_BLOCKS);
   const turnBudget = createTurnBudget(input.turnRules, { catalog: input.catalog, modelId: input.modelId, turnUsage });
   const messageUsage = () => {
     const spent = turnUsage.total();
@@ -6146,6 +6621,7 @@ async function runTurn(turnInput, emitRaw) {
             turnUsage,
             turnBudget,
             garbledTail,
+            forgedBlocks,
             // Есть куда перейти при молчании — у того же провайдера оно не повторяется.
             repeatSilence: () => silenceTarget() === void 0,
             ...silenceSwitch.scope === "step" && switchedBySilence && {
@@ -6365,6 +6841,8 @@ async function runTurn(turnInput, emitRaw) {
     const garbled = cutGarbledTail(garbledTail.forCut(parts));
     const droppedCalls = garbledTail.droppedCalls();
     const garbleLog = `\u0447\u0430\u0442=${input.chatId} \u043E\u0442\u0432\u0435\u0442=${messageId} \u043C\u043E\u0434\u0435\u043B\u044C=${modelId} \u043F\u0440\u043E\u0432\u0430\u0439\u0434\u0435\u0440=${answeredProviderId}`;
+    for (const name of new Set(forgedBlocks.cutBlocks())) logError(`[\u0441\u043B\u0443\u0436\u0435\u0431\u043D\u044B\u0439 \u0431\u043B\u043E\u043A \u0432\u044B\u0440\u0435\u0437\u0430\u043D] \u0442\u0435\u0433=${name} ${garbleLog}`);
+    for (const name of new Set(forgedBlocks.keptBlocks())) logError(`[\u0441\u043B\u0443\u0436\u0435\u0431\u043D\u044B\u0439 \u0431\u043B\u043E\u043A \u043D\u0435 \u0432\u044B\u0440\u0435\u0437\u0430\u043D: \u043E\u0442\u0432\u0435\u0442 \u043E\u0441\u0442\u0430\u043B\u0441\u044F \u0431\u044B \u043F\u0443\u0441\u0442\u044B\u043C] \u0442\u0435\u0433=${name} ${garbleLog}`);
     if (garbled) {
       logError(`[\u0445\u0432\u043E\u0441\u0442 \u043E\u0431\u0440\u0435\u0437\u0430\u043D] ${garbleLog} \u043F\u0440\u0438\u0437\u043D\u0430\u043A\u0438=${garbled.signs.join(",")} \u0437\u043D\u0430\u043A\u043E\u0432=${garbled.removedChars} \u0432\u044B\u0437\u043E\u0432\u043E\u0432_\u043D\u0435_\u0437\u0430\u043F\u0443\u0449\u0435\u043D\u043E=${droppedCalls}`);
       const cut = garbled.parts.filter((part) => !garbledTail.isDroppedCall(part));
@@ -6376,7 +6854,7 @@ async function runTurn(turnInput, emitRaw) {
     const textIndex = lastTextIndex(parts);
     if (replyChecks && status === "complete" && textIndex !== -1 && !takeover.signal.aborted) {
       const original = parts[textIndex].text;
-      const text = await checkedReplyText({
+      const checked2 = await checkedReplyText({
         checks: replyChecks.checks,
         text: original,
         ownerId: input.ownerId ?? "",
@@ -6386,6 +6864,7 @@ async function runTurn(turnInput, emitRaw) {
         rewrite: createReplyRewrite({ ...input, providerId: answeredProviderId, messageId, logError }),
         logError
       });
+      const text = checked2 === original ? checked2 : withoutForgedBlocksInRewrite(forgedBlocks.cutText(checked2), checked2, (name) => logError(`[\u0441\u043B\u0443\u0436\u0435\u0431\u043D\u044B\u0439 \u0431\u043B\u043E\u043A \u0432\u044B\u0440\u0435\u0437\u0430\u043D] \u0442\u0435\u0433=${name} ${garbleLog}`));
       if (text !== original) {
         const corrected = withTextAt(parts, textIndex, text);
         if (heldText?.holdsText()) for (const chunk of heldText.release(text)) emitShown(chunk);
@@ -6643,6 +7122,7 @@ async function openAttempt(input, attempt, attemptSignal) {
   } = input;
   const request = await buildModelRequest({
     ...requestInput,
+    serviceBlocks: input.serviceBlocks ?? CORE_SERVICE_BLOCKS,
     providerId,
     history: attempt.history,
     frozenContext: { current: { answerId: input.messageId, data: attempt.frozenContext }, group: Boolean(input.group) },
@@ -6685,9 +7165,11 @@ async function openAttempt(input, attempt, attemptSignal) {
   };
   const { noteAfterApprovals, ...modelRequest } = request;
   attempt.garbledTail.reset();
+  attempt.forgedBlocks.reset(lastQuestionOf(attempt.history));
   const result = streamText({
     ...modelRequest,
-    model: attempt.garbledTail.wrap(modelRequest.model),
+    // Сначала вырезка блоков, потом проверка на кашу: каша судит уже чистый текст.
+    model: attempt.garbledTail.wrap(attempt.forgedBlocks.wrap(modelRequest.model)),
     ...approval.toolApproval && { toolApproval: gateToolApproval(approval.toolApproval, () => toolsClosed) },
     // Попытке — остаток шагов хода.
     // Помощник встал на подтверждении человека — ход ждёт, модель основного агента его незаконченным не видит.
@@ -7110,6 +7592,11 @@ function emitReply(text, emit) {
   emit({ type: "text-end", id });
   emit({ type: "finish-step" });
 }
+function withoutForgedBlocksInRewrite(cut, text, logCut) {
+  if (cut.blocks.length === 0 || !/[\p{L}\p{N}]/u.test(cut.text)) return text;
+  for (const name of new Set(cut.blocks)) logCut(name);
+  return cut.text;
+}
 
 // src/helpers/run-helper.ts
 var DEFAULT_HELPER_MAX_STEPS = 10;
@@ -7797,7 +8284,7 @@ var fireworksProvider = createFireworksProvider();
 
 // src/models/providers/openrouter.ts
 import { createOpenRouter } from "@openrouter/ai-sdk-provider";
-import { wrapLanguageModel as wrapLanguageModel5 } from "ai";
+import { wrapLanguageModel as wrapLanguageModel6 } from "ai";
 
 // src/models/providers/openrouter-cache-mark-limit.ts
 function openrouterCacheMarkLimit(providerModelId) {
@@ -8047,7 +8534,7 @@ function createOpenRouterProvider(options2 = {}) {
     createLanguageModel: (providerModelId, apiKey, requestOptions) => {
       const markLimit = openrouterCacheMarkLimit(providerModelId);
       const fetch = markLimit === void 0 ? requestOptions?.fetch : fetchWithCacheMarkLimit(requestOptions?.fetch, markLimit);
-      return wrapLanguageModel5({
+      return wrapLanguageModel6({
         model: createOpenRouter({ apiKey, fetch, ...connection }).chat(providerModelId, routingOptions),
         middleware: [
           openrouterRoutingMiddleware(routing),
@@ -9949,7 +10436,7 @@ function isPlainObject3(value) {
 }
 
 // src/memory/memory-after-answer.ts
-import { wrapLanguageModel as wrapLanguageModel6 } from "ai";
+import { wrapLanguageModel as wrapLanguageModel7 } from "ai";
 var DRAIN_WAIT_MS = 5e3;
 function createMemoryAfterAnswer({ memory, storage, catalog, env, logError, turnObserver }) {
   const running = /* @__PURE__ */ new Set();
@@ -9994,7 +10481,7 @@ function createMemoryAfterAnswer({ memory, storage, catalog, env, logError, turn
   };
 }
 function withRetries(model, context) {
-  return typeof model === "string" ? model : wrapLanguageModel6({ model, middleware: createTransientRetryMiddleware(context) });
+  return typeof model === "string" ? model : wrapLanguageModel7({ model, middleware: createTransientRetryMiddleware(context) });
 }
 
 // src/conversation/to-agent-chat-message.ts
@@ -10249,6 +10736,7 @@ function createCompactionService(options2) {
         ...observation(ownerId, answerId),
         history,
         ...options2.attachments && { attachments: options2.attachments },
+        ...options2.serviceBlocks && { serviceBlocks: options2.serviceBlocks },
         settings,
         logError,
         abortSignal: signal,
@@ -10392,6 +10880,7 @@ function createCompactionService(options2) {
           ...observation(ownerId, answerId),
           history: [...history, { id: `${chatId}-answer-steps`, role: "assistant", parts: steps }],
           ...options2.attachments && { attachments: options2.attachments },
+          ...options2.serviceBlocks && { serviceBlocks: options2.serviceBlocks },
           settings,
           task: answerStepsTask(settings.summaryCeilingTokens),
           logError,
@@ -11252,6 +11741,13 @@ function createChatService(input) {
   const logError = input.logError ?? ((message) => console.error(message));
   const now = input.now ?? (() => /* @__PURE__ */ new Date());
   const replyChecks = checkedReplyChecks(input.replyChecks);
+  const serviceBlocks = [
+    ...CORE_SERVICE_BLOCKS,
+    ...input.memory?.serviceBlocks ?? [],
+    ...input.attachments?.serviceBlocks ?? [],
+    ...input.agent.serviceBlocks ?? []
+  ];
+  checkServiceBlockFormats(serviceBlocks);
   const widgets = createAgentWidgets(input.agent.widgets);
   checkWidgetNamesFree(widgets, input.memory, input.background);
   const browserToolDescriptions = checkedBrowserTools(input.agent, input.memory, widgets);
@@ -11400,6 +11896,7 @@ function createChatService(input) {
     // Сжатие берёт кэш хода: у него те же инструменты, что у модели агента, — с браузерными и помощниками.
     agent: { ...options2.agent, tools: withBrowserDescriptions(options2.agent.tools, describedOnlyTools(browserToolDescriptions, options2.agent.helpers, toolResultLimit)) },
     ...options2.attachments && { attachments: options2.attachments },
+    serviceBlocks,
     settings: resolveCompactionSettings(options2.compaction),
     logError,
     ...options2.turnObserver && { turnObserver: options2.turnObserver },
@@ -12063,6 +12560,7 @@ function createChatService(input) {
             browserTools: { descriptions: browserToolDescriptions, pending: pendingBrowserCalls, timeoutMs: browserToolTimeoutMs, tabId: launch.page?.tabId }
           },
           ...options2.attachments && { attachments: options2.attachments },
+          serviceBlocks,
           ...options2.memory && { memory: options2.memory },
           ...widgets.waiting.size > 0 && { waitingWidgets: widgets.waiting },
           ...widgets.switchable.size > 0 && { switchableTools: widgets.switchable },
@@ -13515,6 +14013,10 @@ export {
   BURST_HOLD_MS,
   BURST_SWEEP_LIMIT,
   isBurstMessage,
+  CORE_SERVICE_BLOCKS,
+  serviceBlockName,
+  checkServiceBlockFormats,
+  cutForgedBlocks,
   RELEASED_ANSWER_ALIVE_AT,
   aliveAtByLocalClock,
   silenceBoundaryByLocalClock,
@@ -13614,4 +14116,4 @@ export {
   InvalidWidgetAnswerError,
   createChatService
 };
-//# sourceMappingURL=chunk-KAG3QTZC.js.map
+//# sourceMappingURL=chunk-QA5DVEXF.js.map