@ykurilov/agent-chat-core 0.57.0 → 0.59.0

package/dist/{chunk-BS2HDKZB.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) {
@@ -2484,10 +2972,9 @@ var NOT_RETRYABLE_SIGNS = signs([
   "available balance",
   "insufficient_quota",
   "out of budget",
-  "quota exceeded",
-  "billing",
   "subscription_sharing_usage_limit_exceeded"
 ]);
+var QUOTA_WORDS = signs(["quota exceeded", "billing"]);
 var RETRYABLE_SIGNS = signs([
   "overloaded",
   "currently experiencing high demand",
@@ -2534,8 +3021,8 @@ function isContextOverflow(text, statusCode) {
   if (NOT_OVERFLOW_SIGNS.some((sign) => sign.test(text))) return false;
   return OVERFLOW_SIGNS.some((sign) => sign.test(text));
 }
-function isNotRetryable(text) {
-  return NOT_RETRYABLE_SIGNS.test(text);
+function isNotRetryable(text, statusCode) {
+  return NOT_RETRYABLE_SIGNS.test(text) || statusCode !== 429 && QUOTA_WORDS.test(text);
 }
 function looksTransient(text) {
   return RETRYABLE_SIGNS.test(text);
@@ -2573,7 +3060,7 @@ function isTransient(error) {
   if (verdict === "false") return false;
   const status = errorStatusCode(error);
   const text = errorText(error);
-  if (isNotRetryable(text) || isContextOverflow(text, status)) return false;
+  if (isNotRetryable(text, status) || isContextOverflow(text, status)) return false;
   if (status !== void 0) return RETRYABLE_STATUS_CODES.has(status) || status >= 500;
   if (APICallError2.isInstance(error) && error.isRetryable) return true;
   return looksTransient(text);
@@ -2747,6 +3234,9 @@ function sleep(ms, signal) {
 }
 
 // src/provider-errors/classify-provider-error.ts
+var KEY_SIGNS = /api[ _-]?key|authenticat|unauthori[sz]ed|credential|access[ _-]?token|key (?:is )?(?:invalid|revoked|expired|disabled)/i;
+var FUNDS_SIGNS = /key limit exceeded|insufficient (?:credits|funds|balance)/i;
+var MODERATION_SIGNS = /flagged|moderation|content[ _-]?policy|safety/i;
 var RATE_LIMIT_SIGNS = /rate.?limit|too many requests|throttl|please wait|ResourceExhausted/i;
 function classifyProviderError(error, provider) {
   if (error instanceof MissingProviderKeyError) return "invalid_key";
@@ -2756,8 +3246,12 @@ function classifyProviderError(error, provider) {
   for (const hint of provider?.errorHints ?? []) {
     if (hint.match.test(text)) return hint.kind;
   }
-  if (status === 401 || status === 403) return "invalid_key";
-  if (status === 402 || isNotRetryable(text)) return "insufficient_funds";
+  if (status === 401) return "invalid_key";
+  if (status === 403) {
+    if (KEY_SIGNS.test(text)) return "invalid_key";
+    return FUNDS_SIGNS.test(text) || isNotRetryable(text) ? "insufficient_funds" : "other";
+  }
+  if (status === 402 || isNotRetryable(text, status)) return "insufficient_funds";
   if (isContextOverflow(text, status)) return "context_overflow";
   if (status === 429) return "rate_limited";
   if (isProviderSilence(cause)) return "overloaded";
@@ -2765,6 +3259,10 @@ function classifyProviderError(error, provider) {
   if (RATE_LIMIT_SIGNS.test(text)) return "rate_limited";
   return looksTransient(text) ? "overloaded" : "other";
 }
+function isAccessRefusal(error) {
+  const cause = underlyingError(error);
+  return errorStatusCode(cause) === 403 && !MODERATION_SIGNS.test(errorText(cause));
+}
 
 // src/provider-errors/provider-failure-log.ts
 import { APICallError as APICallError3 } from "ai";
@@ -2790,6 +3288,49 @@ function oneLine(text) {
   return text.replace(/\s*[\r\n]+\s*/g, " ");
 }
 
+// src/provider-errors/provider-outages.ts
+function isProviderOutage(kind) {
+  return kind === "insufficient_funds" || kind === "invalid_key";
+}
+var PROVIDER_OUTAGE_PAUSE_MS = 5 * 6e4;
+var PROVIDER_OUTAGE_ALERT_EVERY_MS = 15 * 6e4;
+var PROVIDER_OUTAGE_PROBE_MS = 6e4;
+var SAID = {
+  insufficient_funds: "\u043A\u043E\u043D\u0447\u0438\u043B\u0438\u0441\u044C \u0434\u0435\u043D\u044C\u0433\u0438",
+  invalid_key: "\u043A\u043B\u044E\u0447 \u043D\u0435 \u043F\u0440\u0438\u043D\u044F\u0442"
+};
+function createProviderOutages(options2) {
+  const outages = /* @__PURE__ */ new Map();
+  const alertedAt = /* @__PURE__ */ new Map();
+  const pausedKind = (providerId) => {
+    const outage = outages.get(providerId);
+    if (!outage) return void 0;
+    const time = options2.now();
+    return time < outage.pausedUntil || time < (outage.probeUntil ?? 0) ? outage.kind : void 0;
+  };
+  return {
+    report({ providerId, kind, fallbackProviderId, fallbacksPaused }) {
+      const time = options2.now();
+      outages.set(providerId, { kind, pausedUntil: time + PROVIDER_OUTAGE_PAUSE_MS });
+      const last = alertedAt.get(providerId);
+      if (last !== void 0 && time - last < PROVIDER_OUTAGE_ALERT_EVERY_MS) return;
+      alertedAt.set(providerId, time);
+      const route = fallbackProviderId !== void 0 ? `\u0445\u043E\u0434\u044B \u0438\u0434\u0443\u0442 \u0447\u0435\u0440\u0435\u0437 \u0437\u0430\u043F\u0430\u0441\u043D\u043E\u0439 ${fallbackProviderId}` : `${fallbacksPaused ? "\u0437\u0430\u043F\u0430\u0441\u043D\u044B\u0435 \u0442\u043E\u0436\u0435 \u043D\u0430 \u043F\u0430\u0443\u0437\u0435" : "\u0437\u0430\u043F\u0430\u0441\u043D\u043E\u0433\u043E \u043D\u0435\u0442"}, \u0445\u043E\u0434\u044B \u043F\u0430\u0434\u0430\u044E\u0442 \u0441 \u043E\u0448\u0438\u0431\u043A\u043E\u0439`;
+      options2.logError(`[\u0412\u041D\u0418\u041C\u0410\u041D\u0418\u0415 \u043F\u0440\u043E\u0432\u0430\u0439\u0434\u0435\u0440] ${providerId}: ${SAID[kind]} \u2014 ${route}`);
+    },
+    pausedKind,
+    admit(providerId) {
+      const kind = pausedKind(providerId);
+      const outage = outages.get(providerId);
+      if (kind === void 0 && outage) outage.probeUntil = options2.now() + PROVIDER_OUTAGE_PROBE_MS;
+      return kind;
+    },
+    recovered(providerId) {
+      outages.delete(providerId);
+    }
+  };
+}
+
 // src/tool-approval/tool-approval-policy.ts
 var needsApprovalOf = (tool4) => tool4.needsApproval;
 function prepareToolApproval(tools, alwaysAllowed) {
@@ -2865,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;
@@ -3085,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;
@@ -3095,7 +3636,7 @@ function observeModelCalls(model, context) {
     attempts.set(params.prompt, attempt);
     return attempt;
   };
-  return wrapLanguageModel2({
+  return wrapLanguageModel3({
     model,
     middleware: {
       specificationVersion: "v4",
@@ -3526,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;
@@ -3698,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");
@@ -3870,7 +4396,7 @@ function createGarbledTailGuard() {
     /** Модель попытки под присмотром: каждый запрос — новый шаг. */
     wrap(model) {
       if (typeof model === "string") return model;
-      return wrapLanguageModel3({
+      return wrapLanguageModel4({
         model,
         middleware: {
           specificationVersion: "v4",
@@ -3975,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");
 }
@@ -4012,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, {
@@ -4097,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",
@@ -4117,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;
@@ -4348,8 +4875,14 @@ function decideNextAttempt(result, state) {
     if (state.overflowCompaction?.answerSteps) return { action: "compact-and-continue", scope: "answer-steps" };
     return { action: "fail" };
   }
-  if (!TRANSIENT_KINDS.has(result.kind)) return { action: "fail" };
+  if (isProviderOutage(result.kind)) {
+    const next2 = state.fallbackProviderIds[0];
+    return next2 === void 0 ? { action: "fail" } : { action: "fallback", providerId: next2 };
+  }
+  const accessRefused = result.kind === "other" && isAccessRefusal(result.error);
+  if (!TRANSIENT_KINDS.has(result.kind) && !accessRefused) return { action: "fail" };
   if (result.contentSeen) {
+    if (accessRefused) return { action: "fail" };
     const auto = state.autoContinue;
     if (!auto || auto.approvalRequested || auto.done >= AUTO_CONTINUES_PER_TURN) return { action: "fail" };
     return { action: "auto-continue", pauseMs: autoContinuePauseMs({ index: auto.done, error: result.error, random: auto.random ?? Math.random }) };
@@ -4358,6 +4891,10 @@ function decideNextAttempt(result, state) {
   if (state.fallbackUsed || next === void 0) return { action: "fail" };
   return { action: "fallback", providerId: next };
 }
+function errorKindForPerson(lastKind, firstOutage) {
+  if (firstOutage === void 0 || TRANSIENT_KINDS.has(lastKind) || lastKind === "context_overflow") return lastKind;
+  return firstOutage;
+}
 function checkProviderFallback(setting, catalog) {
   if (setting === void 0 || setting === false) return;
   if (typeof setting !== "object" || setting === null || Array.isArray(setting)) {
@@ -5907,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();
@@ -5995,13 +6533,21 @@ async function runTurn(turnInput, emitRaw) {
         const seen = latestFrozenContextOf(resume.message.parts);
         if (seen) resumeNote = { ...resumeNote ?? { blocks: seen.blocks, sent: { changed: [], removed: [] }, base: messageId }, notices: turnNotices };
       }
-      const fallbackProviderIds = fallbackProviders({
+      const outages = input.providerOutages ?? createProviderOutages({ now: () => (input.now ?? (() => /* @__PURE__ */ new Date()))().getTime(), logError });
+      const allFallbackIds = fallbackProviders({
         catalog: input.catalog,
         modelId,
         chosenProviderId: input.providerId,
         env: input.env,
         ...input.providerFallback !== void 0 && { setting: input.providerFallback }
       });
+      const fallbackProviderIds = allFallbackIds.filter((candidate) => outages.pausedKind(candidate) === void 0);
+      let firstOutage;
+      const primaryPaused = outages.admit(input.providerId);
+      if (primaryPaused !== void 0 && fallbackProviderIds[0] !== void 0) {
+        providerId = fallbackProviderIds[0];
+        logError(`[\u0437\u0430\u043F\u0430\u0441\u043D\u043E\u0439 \u043F\u0440\u043E\u0432\u0430\u0439\u0434\u0435\u0440] \u0447\u0430\u0442=${input.chatId} \u043C\u043E\u0434\u0435\u043B\u044C=${modelId} \u0441=${input.providerId} \u043D\u0430=${providerId} \u043F\u0440\u0438\u0447\u0438\u043D\u0430=${primaryPaused} \u043E\u0441\u043D\u043E\u0432\u043D\u043E\u0439 \u043D\u0430 \u043F\u0430\u0443\u0437\u0435`);
+      }
       emit({ type: "start", messageId, messageMetadata: { modelId, providerId: input.providerId } });
       if (input.liveDemos && chatHasExternalContent(await storage.listMessages(input.chatId)) && externalContent.announce()) emitRaw(externalContentChunk());
       const silenceSetting = resolveSilenceSwitch(input.providerFallback);
@@ -6075,6 +6621,7 @@ async function runTurn(turnInput, emitRaw) {
             turnUsage,
             turnBudget,
             garbledTail,
+            forgedBlocks,
             // Есть куда перейти при молчании — у того же провайдера оно не повторяется.
             repeatSilence: () => silenceTarget() === void 0,
             ...silenceSwitch.scope === "step" && switchedBySilence && {
@@ -6092,13 +6639,14 @@ async function runTurn(turnInput, emitRaw) {
         } catch (error2) {
           if (error2 instanceof MissingProviderKeyError) logError(error2.message);
           if (!input.abortSignal.aborted) {
-            errorKind = classify(error2);
+            errorKind = errorKindForPerson(classify(error2), firstOutage);
             errors = [{ type: "error", errorText: errorKind }];
           }
           break;
         }
         const { result } = attempt;
         historyRewritten = false;
+        if (result.outcome === "ok") outages.recovered(providerId);
         if (result.outcome !== "failed" || result.contentSeen) answeredProviderId = providerId;
         if (result.outcome === "ok" && backToPrimary) {
           backToPrimary = false;
@@ -6133,12 +6681,24 @@ async function runTurn(turnInput, emitRaw) {
           silenceSwitch: { done: silenceSwitches, max: silenceSwitch.maxSwitches, nextProviderId: silenceTarget() }
         });
         let next = stepsDone < maxSteps ? decideNextAttempt(result, nextState()) : { action: "fail" };
+        const outage = isProviderOutage(result.kind) ? result.kind : void 0;
+        if (outage) {
+          if (providerId === input.providerId) firstOutage ??= outage;
+          outages.report({
+            providerId,
+            kind: outage,
+            ...next.action === "fallback" ? { fallbackProviderId: next.providerId } : { fallbacksPaused: allFallbackIds.some((candidate) => candidate !== providerId && outages.pausedKind(candidate) !== void 0) }
+          });
+        }
         if (next.action === "fallback") {
           logError(`[\u0437\u0430\u043F\u0430\u0441\u043D\u043E\u0439 \u043F\u0440\u043E\u0432\u0430\u0439\u0434\u0435\u0440] \u0447\u0430\u0442=${input.chatId} \u043C\u043E\u0434\u0435\u043B\u044C=${modelId} \u0441=${providerId} \u043D\u0430=${next.providerId} \u043F\u0440\u0438\u0447\u0438\u043D\u0430=${result.kind} \u043A\u044D\u0448 \u043F\u043E\u0442\u0435\u0440\u044F\u043D`);
-          fallbackUsed = true;
+          if (!outage) fallbackUsed = true;
           switchedBySilence = false;
           providerId = next.providerId;
-          answer.update(parts2, { modelId, providerId: answeredProviderId });
+          const closing2 = result.contentSeen ? [...openParts.closingChunks(), ...closingChunksForHangingCalls(parts2)] : [];
+          for (const chunk of closing2) emit(chunk);
+          if (closing2.length > 0) answer.continueAfterBreak(parts2, { modelId, providerId: answeredProviderId });
+          else answer.update(parts2, { modelId, providerId: answeredProviderId });
           turnUsage.closeAttempt();
           if (input.abortSignal.aborted) break;
           continue;
@@ -6210,8 +6770,8 @@ async function runTurn(turnInput, emitRaw) {
           turnUsage.closeAttempt();
           continue;
         }
-        errorKind = result.kind;
-        errors = attempt.errors;
+        errorKind = errorKindForPerson(result.kind, firstOutage);
+        errors = errorKind === result.kind ? attempt.errors : [{ type: "error", errorText: errorKind }];
         terminal = attempt.terminal;
         logError(
           describeProviderFailure(result.error, { chatId: input.chatId, modelId, providerId, kind: result.kind, env: input.env, catalog: input.catalog })
@@ -6281,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));
@@ -6292,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 ?? "",
@@ -6302,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);
@@ -6559,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) },
@@ -6601,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) },
     // Попытке — остаток шагов хода.
     // Помощник встал на подтверждении человека — ход ждёт, модель основного агента его незаконченным не видит.
@@ -6823,6 +7389,7 @@ function helperRunContext(input, toolQueue, logError) {
     ...input.toolTimeout && { toolTimeout: input.toolTimeout },
     ...input.sequentialTools && { sequentialTools: input.sequentialTools },
     ...input.providerFallback !== void 0 && { providerFallback: input.providerFallback },
+    ...input.providerOutages && { providerOutages: input.providerOutages },
     ...input.modelSilence && { modelSilence: input.modelSilence },
     ...input.turnObserver && { turnObserver: input.turnObserver },
     ...input.assertWithinLimit && { assertWithinLimit: input.assertWithinLimit }
@@ -7025,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;
@@ -7053,16 +7625,26 @@ async function* helperSteps(input) {
   const messages = [...input.priorMessages ?? []];
   const maxSteps = helper.maxSteps ?? DEFAULT_HELPER_MAX_STEPS;
   const { modelId } = helper.model;
-  const fallbackProviderIds = fallbackProviders({
+  const outages = context.providerOutages ?? createProviderOutages({ now: Date.now, logError: context.logError });
+  const allFallbackIds = fallbackProviders({
     catalog: context.catalog,
     modelId,
     chosenProviderId: helper.model.providerId,
     env: context.env,
     ...context.providerFallback !== void 0 && { setting: context.providerFallback }
   });
+  const fallbackProviderIds = allFallbackIds.filter((candidate) => outages.pausedKind(candidate) === void 0);
   const toolQueue = context.toolQueue ?? createToolQueue();
   let providerId = helper.model.providerId;
   let fallbackUsed = false;
+  let firstOutage;
+  const primaryPaused = outages.admit(providerId);
+  if (primaryPaused !== void 0 && fallbackProviderIds[0] !== void 0) {
+    context.logError(
+      `[\u0437\u0430\u043F\u0430\u0441\u043D\u043E\u0439 \u043F\u0440\u043E\u0432\u0430\u0439\u0434\u0435\u0440] \u0447\u0430\u0442=${context.chatId} \u043F\u043E\u043C\u043E\u0449\u043D\u0438\u043A=${input.name} \u043C\u043E\u0434\u0435\u043B\u044C=${modelId} \u0441=${providerId} \u043D\u0430=${fallbackProviderIds[0]} \u043F\u0440\u0438\u0447\u0438\u043D\u0430=${primaryPaused} \u043E\u0441\u043D\u043E\u0432\u043D\u043E\u0439 \u043D\u0430 \u043F\u0430\u0443\u0437\u0435`
+    );
+    providerId = fallbackProviderIds[0];
+  }
   let externalContent = false;
   const report = (status, extra = {}) => ({
     messages: [...messages],
@@ -7089,17 +7671,28 @@ async function* helperSteps(input) {
     } catch (error) {
       if (abortSignal.aborted) throw error;
       const kind = classifyProviderError(error, provider);
-      const next = decideNextAttempt({ outcome: "failed", kind, error, contentSeen: false }, { fallbackUsed, fallbackProviderIds });
+      const candidates = providerId === helper.model.providerId ? fallbackProviderIds : fallbackProviderIds.slice(fallbackProviderIds.indexOf(providerId) + 1);
+      const next = decideNextAttempt({ outcome: "failed", kind, error, contentSeen: false }, { fallbackUsed, fallbackProviderIds: candidates });
+      const outage = isProviderOutage(kind) ? kind : void 0;
+      if (outage) {
+        if (providerId === helper.model.providerId) firstOutage ??= outage;
+        outages.report({
+          providerId,
+          kind: outage,
+          ...next.action === "fallback" ? { fallbackProviderId: next.providerId } : { fallbacksPaused: allFallbackIds.some((candidate) => candidate !== providerId && outages.pausedKind(candidate) !== void 0) }
+        });
+      }
       if (next.action === "fallback") {
         context.logError(`[\u0437\u0430\u043F\u0430\u0441\u043D\u043E\u0439 \u043F\u0440\u043E\u0432\u0430\u0439\u0434\u0435\u0440] \u0447\u0430\u0442=${context.chatId} \u043F\u043E\u043C\u043E\u0449\u043D\u0438\u043A=${input.name} \u043C\u043E\u0434\u0435\u043B\u044C=${modelId} \u0441=${providerId} \u043D\u0430=${next.providerId} \u043F\u0440\u0438\u0447\u0438\u043D\u0430=${kind}`);
-        fallbackUsed = true;
+        if (!outage) fallbackUsed = true;
         providerId = next.providerId;
         continue;
       }
       context.logError(describeProviderFailure(error, { chatId: context.chatId, modelId, providerId, kind, env: context.env, catalog: context.catalog }));
-      yield report("failed", { error: FAILURE_REASONS[kind] });
+      yield report("failed", { error: FAILURE_REASONS[errorKindForPerson(kind, firstOutage)] });
       return;
     }
+    outages.recovered(providerId);
     messages.push(...response);
     externalContent ||= callsExternalContentTool(messages, tools);
     const pendingApproval = pendingApprovalOf2(messages, tools);
@@ -7691,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) {
@@ -7941,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),
@@ -9843,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();
@@ -9888,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
@@ -10143,6 +10736,7 @@ function createCompactionService(options2) {
         ...observation(ownerId, answerId),
         history,
         ...options2.attachments && { attachments: options2.attachments },
+        ...options2.serviceBlocks && { serviceBlocks: options2.serviceBlocks },
         settings,
         logError,
         abortSignal: signal,
@@ -10286,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,
@@ -11035,6 +11630,7 @@ var InvalidWidgetAnswerError = class extends Error {
   }
 };
 var FAR_FUTURE_ISO = "9999-12-31T23:59:59.999Z";
+var abandonedBurstReceivers = /* @__PURE__ */ new WeakMap();
 var TurnEndedBeforeSubscribeError = class extends Error {
   constructor(chatId) {
     super(`\u0425\u043E\u0434 \u0432 \u0447\u0430\u0442\u0435 ${chatId} \u0437\u0430\u043A\u043E\u043D\u0447\u0438\u043B\u0441\u044F \u0434\u043E \u043F\u043E\u0434\u043F\u0438\u0441\u043A\u0438`);
@@ -11145,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);
@@ -11232,6 +11835,7 @@ function createChatService(input) {
   const modelSilence = resolveModelSilence(modelSilenceTimeout);
   const cacheMissWatch = cacheMissLog === false ? void 0 : createCacheMissWatch({ logError });
   checkProviderFallback(providerFallback, options2.catalog);
+  const providerOutages = createProviderOutages({ now: () => now().getTime(), logError });
   const placeMaxLength = resolvePlaceMaxLength(placeMaxLengthSetting);
   const browserToolTimeoutMs = resolveBrowserToolTimeoutMs(browserToolTimeoutSetting);
   const pendingBrowserCalls = createPendingBrowserCalls();
@@ -11292,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 },
@@ -11907,6 +12512,7 @@ function createChatService(input) {
           modelSilence,
           ...limits.maxOutputTokens !== void 0 && { maxOutputTokens: limits.maxOutputTokens },
           ...providerFallback !== void 0 && { providerFallback },
+          providerOutages,
           ...cacheMissWatch && { cacheMissWatch },
           ...options2.turnObserver && { turnObserver: options2.turnObserver },
           ...options2.limits && { assertWithinLimit: () => assertWithinSpendingLimit(chat.ownerId, chatId) },
@@ -11954,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 },
@@ -12229,10 +12836,10 @@ function createChatService(input) {
       ...page && { page }
     });
   }
-  function renewingBurstHold(chatId, messageId, dueAt) {
+  function renewingBurstHold(chatId, messageId, dueAt, holder) {
     const timer = setInterval(() => {
       const heldUntil = new Date(Math.max(now().getTime(), dueAt) + BURST_HOLD_MS).toISOString();
-      storage.renewPendingBurst({ chatId, messageId, holder: copyId, heldUntil }).then(
+      storage.renewPendingBurst({ chatId, messageId, holder, heldUntil }).then(
         (held) => {
           if (!held) clearInterval(timer);
         },
@@ -12246,7 +12853,7 @@ function createChatService(input) {
   function answeringRecordedBurst(ownerId, chatId, questionId, page, burst) {
     const unattended = burst.kept && burst.unattended === true;
     if (!burst.kept || !keepsPendingBursts) return burstWaits.holding(chatId, () => answeringBurst(ownerId, chatId, questionId, page, unattended));
-    const stopRenewing = renewingBurstHold(chatId, questionId, burst.dueAt);
+    const stopRenewing = renewingBurstHold(chatId, questionId, burst.dueAt, burst.holder ?? copyId);
     const answering = burstWaits.holding(chatId, () => answeringBurst(ownerId, chatId, questionId, page, unattended)).finally(stopRenewing);
     void answering.then(
       () => true,
@@ -12272,6 +12879,37 @@ function createChatService(input) {
     const why = error instanceof TurnRefusedError ? `\u043E\u0442\u043A\u0430\u0437 \u043F\u0440\u0438\u043B\u043E\u0436\u0435\u043D\u0438\u044F ${error.code}: ${error.message}` : error instanceof Error ? error.message : String(error);
     logError(`\u0425\u043E\u0434 \u043D\u0430 \u0431\u0440\u043E\u0448\u0435\u043D\u043D\u0443\u044E \u043F\u0430\u0447\u043A\u0443 \u0447\u0430\u0442\u0430 ${chatId} \u043D\u0435 \u043D\u0430\u0447\u0430\u043B\u0441\u044F: ${why}`);
   }
+  async function receivingAbandonedBurst(burst) {
+    if (burstWaits.has(burst.chatId)) return;
+    await answeringRecordedBurst(burst.ownerId, burst.chatId, burst.messageId, burst.page, { kept: true, dueAt: Date.parse(burst.dueAt), unattended: true, holder: burst.holder }).then(
+      () => {
+      },
+      (error) => reportingAbandonedBurst(burst.chatId, error)
+    );
+  }
+  async function routingAbandonedBurst(burst) {
+    const serviceFor = options2.abandonedBursts?.serviceFor;
+    if (!serviceFor) return receivingAbandonedBurst(burst);
+    let target;
+    try {
+      const chat = await storage.getChat(burst.chatId);
+      if (!chat) return receivingAbandonedBurst(burst);
+      target = await serviceFor({ ownerId: burst.ownerId, chatId: burst.chatId, chat });
+    } catch (error) {
+      logError(`\u0421\u043B\u0443\u0436\u0431\u0430 \u0434\u043B\u044F \u0431\u0440\u043E\u0448\u0435\u043D\u043D\u043E\u0439 \u043F\u0430\u0447\u043A\u0438 \u0447\u0430\u0442\u0430 ${burst.chatId} \u043D\u0435 \u043D\u0430\u0448\u043B\u0430\u0441\u044C (serviceFor): ${error instanceof Error ? error.message : String(error)} \u2014 \u043F\u0430\u0447\u043A\u0430 \u0436\u0434\u0451\u0442 \u0441\u043B\u0435\u0434\u0443\u044E\u0449\u0435\u0433\u043E \u043E\u0431\u0445\u043E\u0434\u0430`);
+      return;
+    }
+    if (!target) {
+      logError(`\u0414\u043B\u044F \u0431\u0440\u043E\u0448\u0435\u043D\u043D\u043E\u0439 \u043F\u0430\u0447\u043A\u0438 \u0447\u0430\u0442\u0430 ${burst.chatId} \u043D\u0435\u0442 \u0441\u043B\u0443\u0436\u0431\u044B (serviceFor \u2192 ${String(target)}): \u043F\u0430\u0447\u043A\u0430 \u0436\u0434\u0451\u0442 \u0441\u043B\u0435\u0434\u0443\u044E\u0449\u0435\u0433\u043E \u043E\u0431\u0445\u043E\u0434\u0430`);
+      return;
+    }
+    const receive = abandonedBurstReceivers.get(target);
+    if (!receive) {
+      logError(`serviceFor \u0434\u043B\u044F \u0431\u0440\u043E\u0448\u0435\u043D\u043D\u043E\u0439 \u043F\u0430\u0447\u043A\u0438 \u0447\u0430\u0442\u0430 ${burst.chatId} \u0432\u0435\u0440\u043D\u0443\u043B \u043D\u0435 \u0441\u043B\u0443\u0436\u0431\u0443 \u0447\u0430\u0442\u0430 SDK: \u043F\u0430\u0447\u043A\u0430 \u0436\u0434\u0451\u0442 \u0441\u043B\u0435\u0434\u0443\u044E\u0449\u0435\u0433\u043E \u043E\u0431\u0445\u043E\u0434\u0430`);
+      return;
+    }
+    await receive(burst);
+  }
   function sweepingBursts(take) {
     if (!keepsPendingBursts || closing) return Promise.resolve();
     const sweep = (async () => {
@@ -12286,9 +12924,8 @@ function createChatService(input) {
         const taken = await storage.takeAbandonedBursts({ ...take, holder: copyId, heldUntil, limit: free });
         if (taken.length === 0) return;
         for (const burst of taken) {
-          if (burstWaits.has(burst.chatId)) continue;
           burstDecisions++;
-          answeringRecordedBurst(burst.ownerId, burst.chatId, burst.messageId, burst.page, { kept: true, dueAt: Date.parse(burst.dueAt), unattended: true }).catch((error) => reportingAbandonedBurst(burst.chatId, error)).finally(releasingBurstDecision);
+          void routingAbandonedBurst(burst).finally(releasingBurstDecision);
         }
       }
     })().catch((error) => logError(`\u041E\u0431\u0445\u043E\u0434 \u0436\u0434\u0443\u0449\u0438\u0445 \u043F\u0430\u0447\u0435\u043A \u043D\u0435 \u0443\u0434\u0430\u043B\u0441\u044F: ${error instanceof Error ? error.message : String(error)}`)).finally(() => burstSweeps.delete(sweep));
@@ -13203,6 +13840,7 @@ function createChatService(input) {
           modelSilence,
           logError,
           ...providerFallback !== void 0 && { providerFallback },
+          providerOutages,
           ...options2.turnObserver && { turnObserver: options2.turnObserver },
           ...options2.limits && { assertWithinLimit: () => assertWithinSpendingLimit(ownerId, chatId) }
         });
@@ -13212,6 +13850,7 @@ function createChatService(input) {
       helpers: backgroundHelpers
     };
   }
+  abandonedBurstReceivers.set(service, receivingAbandonedBurst);
   return service;
   function isDetachedAnswer(last, runningId) {
     return runningId === null && last?.status === "streaming" && !liveAnswerIds.has(last.id);
@@ -13374,6 +14013,10 @@ export {
   BURST_HOLD_MS,
   BURST_SWEEP_LIMIT,
   isBurstMessage,
+  CORE_SERVICE_BLOCKS,
+  serviceBlockName,
+  checkServiceBlockFormats,
+  cutForgedBlocks,
   RELEASED_ANSWER_ALIVE_AT,
   aliveAtByLocalClock,
   silenceBoundaryByLocalClock,
@@ -13473,4 +14116,4 @@ export {
   InvalidWidgetAnswerError,
   createChatService
 };
-//# sourceMappingURL=chunk-BS2HDKZB.js.map
+//# sourceMappingURL=chunk-QA5DVEXF.js.map