@ykurilov/agent-chat-core 0.56.0 → 0.58.0

package/dist/{chunk-7M7M7DAN.js → chunk-KAG3QTZC.js}

@@ -3,7 +3,7 @@ import {
   TurnRefusedError,
   normalizeTurnRefusal,
   validateAppEvent
-} from "./chunk-PWGI6NH6.js";
+} from "./chunk-FOAIG4DY.js";
 
 // src/conversation/types.ts
 var CURRENT_FORMAT_VERSION = 1;
@@ -1718,6 +1718,9 @@ var DEFAULT_BURST_QUIET_MS = 3e3;
 var MAX_BURST_QUIET_MS = 6e5;
 var BURST_PENDING_GRACE_MS = 12e4;
 var BURST_BUSY_RETRY_MS = 1e3;
+var BURST_HOLD_MS = 3e4;
+var BURST_HOLD_RENEW_MS = 1e4;
+var BURST_SWEEP_LIMIT = 10;
 function burstPart(quietMs, at) {
   return { type: BURST_PART_TYPE, data: { quietMs, at } };
 }
@@ -1826,6 +1829,9 @@ function createBurstWaits() {
     wake(chatId) {
       for (const entry of [...timers]) if (entry.chatId === chatId) entry.done();
     },
+    wakeAll() {
+      for (const entry of [...timers]) entry.done();
+    },
     has: (chatId) => waiting.has(chatId),
     async holding(chatId, work) {
       enter(chatId);
@@ -2478,10 +2484,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",
@@ -2528,8 +2533,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);
@@ -2567,7 +2572,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);
@@ -2741,6 +2746,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";
@@ -2750,8 +2758,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";
@@ -2759,6 +2771,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";
@@ -2784,6 +2800,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) {
@@ -2859,7 +2918,7 @@ function usageMinusJournaled(usage, journaled) {
 }
 
 // src/agent-run/build-model-request.ts
-import { convertToModelMessages, wrapLanguageModel as wrapLanguageModel3 } from "ai";
+import { convertToModelMessages, wrapLanguageModel as wrapLanguageModel4 } from "ai";
 
 // src/conversation/hanging-tool-calls.ts
 var PRELIMINARY_OUTPUT_MAX_LENGTH = 2e3;
@@ -3535,6 +3594,37 @@ function withUnansweredMarked(messages) {
   );
 }
 
+// src/agent-run/staff-replies.ts
+function isStaffReply(message) {
+  if (message.role !== "user") return false;
+  const notices = message.parts.flatMap(noticesOfPart);
+  return notices.length > 0 && notices.every((notice) => notice.kind === "staff");
+}
+function staffPartsJoined(parts) {
+  return parts.flatMap((part) => {
+    if (part.type !== AGENT_NOTICE_PART_TYPE) return joinedParts([part]);
+    const text = noticePartForModel(part);
+    return text ? [{ type: "text", text: `
+
+${text.text}` }] : [];
+  });
+}
+function withStaffRepliesJoined(history) {
+  const joined = [];
+  let afterStaff = false;
+  let changed = false;
+  for (const message of history) {
+    const previous = joined.at(-1);
+    const staff = isStaffReply(message);
+    if (previous?.role === "user" && message.role === "user" && (staff || afterStaff)) {
+      joined[joined.length - 1] = { ...previous, parts: [...previous.parts, ...staff ? staffPartsJoined(message.parts) : joinedParts(message.parts)] };
+      changed = true;
+    } else joined.push(message);
+    afterStaff = staff;
+  }
+  return changed ? joined : history;
+}
+
 // src/frozen-context/frozen-context-messages.ts
 function frozenContextBase(history) {
   for (let index = history.length - 1; index >= 0; index -= 1) {
@@ -3660,6 +3750,298 @@ function withoutUndelivered(history) {
   return dropped.size === 0 ? history : history.filter((_, index) => !dropped.has(index));
 }
 
+// src/agent-run/garbled-tail.ts
+import { wrapLanguageModel as wrapLanguageModel3 } 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");
+var ROLE_LINE = /(?<=^|\n)(user|assistant)(?=[ \t]*(?:\n|$)|[А-ЯЁа-яё])/g;
+var TOKEN_ROLE_LINE = /(?<=^|\n)(?:(?:<\|im_start\|>|<\|start_header_id\|>)(?:user|assistant)\b|<\|(?:user|assistant)\|>|<｜(?:User|Assistant)｜>)/g;
+var ANCHOR_HINT = /(?:^|\n)(?:(?:user|assistant)(?:[ \t]*(?:\n|$)|[А-ЯЁа-яё])|(?:<\|im_start\|>|<\|start_header_id\|>)(?:user|assistant)|<\|(?:user|assistant)\|>|<｜(?:User|Assistant)｜>)/;
+var ROLE_TOKEN = /(?:<\|im_start\|>|<\|start_header_id\|>)(user|assistant)\b|<\|(user|assistant)\|>|<｜(User|Assistant)｜>/g;
+var GLUED_SENTENCES = /[а-яё]{2}[.!?…][А-ЯЁ][а-яё]/;
+var changesVerdict = (lines) => ANCHOR_HINT.test(lines) || GLUED_SENTENCES.test(lines) || new RegExp(TOKEN_SOURCE).test(lines);
+var FINISHED = /[.!?…»)"]$/;
+var TRAILING_TOKENS = new RegExp(String.raw`(?:\s|${TOKEN_SOURCE})+$`);
+function findGarbledTail(parts) {
+  if (!parts.some((part) => part.type === "text" && ANCHOR_HINT.test(part.text))) return null;
+  const steps = stepsOf(parts);
+  const markersByStep = steps.map((step) => step.texts.flatMap((text, at) => markersIn(text, step.texts.slice(0, at))));
+  const bareRoles = new Set(markersByStep.flat().flatMap((marker) => marker.bareRole ? [marker.bareRole.name] : []));
+  const tokenRoles = new Set(
+    steps.flatMap((step) => step.texts.flatMap((text) => [...text.visible.matchAll(ROLE_TOKEN)].map((match) => (match[1] ?? match[2] ?? match[3]).toLowerCase())))
+  );
+  const dialog = bareRoles.size > 1;
+  const template = tokenRoles.size > 1;
+  for (const [index, step] of steps.entries()) {
+    const markers = markersByStep[index].filter((marker) => !(dialog && marker.bareRole) && !(template && marker.roleToken));
+    const found = garbleInStep(parts, step, markers);
+    if (found) return found;
+  }
+  return null;
+}
+function cutGarbledTail(parts) {
+  const found = findGarbledTail(parts);
+  if (!found) return null;
+  const stepEnd = parts.findIndex((part, index) => index > found.partIndex && part.type === "step-start");
+  const end = stepEnd === -1 ? parts.length : stepEnd;
+  const cutPart = parts[found.partIndex];
+  const answer = cutPart.text.slice(0, found.offset).replace(TRAILING_TOKENS, "");
+  let removedChars = cutPart.text.length - answer.length;
+  const kept = parts.slice(0, found.partIndex);
+  if (answer) kept.push({ ...cutPart, text: answer, state: "done" });
+  for (const part of parts.slice(found.partIndex + 1, end)) {
+    if (part.type === "text") removedChars += part.text.length;
+    else if (part.type === "reasoning") continue;
+    else if (!(stepEnd === -1 && part.type === LENGTH_CUT_PART_TYPE)) kept.push(part);
+  }
+  kept.push(...parts.slice(end));
+  if (!kept.some((part) => part.type === "text" && /[\p{L}\p{N}]/u.test(part.text.replace(TEMPLATE_TOKEN, "")))) return null;
+  const textIndex = answer ? found.partIndex : parts.slice(0, found.partIndex).findLastIndex((part) => part.type === "text");
+  return { parts: kept, signs: found.signs, removedChars, textIndex };
+}
+function withoutGarbledTails(history) {
+  let changed = false;
+  const cleaned = history.map((message) => {
+    if (message.role !== "assistant") return message;
+    const parts = rememberedCut(message);
+    if (!parts) return message;
+    changed = true;
+    return { ...message, parts };
+  });
+  return changed ? cleaned : history;
+}
+var rememberedCuts = /* @__PURE__ */ new Map();
+var REMEMBERED_CUTS_LIMIT = 500;
+function rememberedCut(message) {
+  if (!message.parts.some((part) => part.type === "text" && ANCHOR_HINT.test(part.text))) return null;
+  const source = JSON.stringify(message.parts);
+  const known = rememberedCuts.get(message.id);
+  if (known?.source === source) return known.parts;
+  const parts = cutGarbledTail(message.parts)?.parts ?? null;
+  rememberedCuts.delete(message.id);
+  rememberedCuts.set(message.id, { source, parts });
+  if (rememberedCuts.size > REMEMBERED_CUTS_LIMIT) rememberedCuts.delete(rememberedCuts.keys().next().value);
+  return parts;
+}
+var DROPPED_CALL = { type: "tool-dropped", toolCallId: "", state: "input-available", input: {} };
+function createGarbledTailGuard() {
+  let parts = [];
+  let garbled = false;
+  let droppedCalls = 0;
+  let hinted = false;
+  const worthChecking = (lines) => {
+    hinted ||= ANCHOR_HINT.test(lines);
+    return hinted && changesVerdict(lines);
+  };
+  const textAt = /* @__PURE__ */ new Map();
+  const open = /* @__PURE__ */ new Set();
+  const droppedIds = /* @__PURE__ */ new Set();
+  const garbledNow = (withCall) => {
+    if (!hinted) return false;
+    const known = parts.map(
+      (part, index) => part.type === "text" && open.has(index) ? { ...part, text: part.text.slice(0, part.text.lastIndexOf("\n") + 1) } : part
+    );
+    return cutGarbledTail(withCall ? [...known, DROPPED_CALL] : known) !== null;
+  };
+  const transform = (part, controller) => {
+    switch (part.type) {
+      case "text-start": {
+        const index = parts.push({ type: "text", text: "" }) - 1;
+        textAt.set(part.id, index);
+        open.add(index);
+        break;
+      }
+      case "text-delta": {
+        if (garbled) return;
+        const index = textAt.get(part.id);
+        if (index === void 0) break;
+        const text = parts[index];
+        const before = text.text.length;
+        const lineStart = text.text.lastIndexOf("\n") + 1;
+        text.text += part.delta;
+        if (!part.delta.includes("\n")) break;
+        if (worthChecking(text.text.slice(lineStart, text.text.lastIndexOf("\n") + 1)) && garbledNow(false)) {
+          garbled = true;
+          const keep = text.text.lastIndexOf("\n") + 1 - before;
+          text.text = text.text.slice(0, before + Math.max(keep, 0));
+          if (keep > 0) controller.enqueue({ ...part, delta: part.delta.slice(0, keep) });
+          return;
+        }
+        break;
+      }
+      case "text-end": {
+        const index = textAt.get(part.id);
+        if (index === void 0 || garbled) break;
+        open.delete(index);
+        const { text } = parts[index];
+        if (worthChecking(text.slice(text.lastIndexOf("\n") + 1)) && garbledNow(false)) garbled = true;
+        break;
+      }
+      case "reasoning-delta":
+        if (garbled) return;
+        break;
+      case "tool-input-start":
+      case "tool-call": {
+        const callId = part.type === "tool-call" ? part.toolCallId : part.id;
+        if (droppedIds.has(callId)) return;
+        const started = part.type === "tool-call" && parts.some((known) => known.toolCallId === callId);
+        if (started) break;
+        if (garbled || garbledNow(true)) {
+          garbled = true;
+          droppedIds.add(callId);
+          droppedCalls += 1;
+          return;
+        }
+        parts.push({ type: "tool-call", toolCallId: callId, state: "input-streaming" });
+        break;
+      }
+      case "tool-input-delta":
+      case "tool-input-end":
+        if (droppedIds.has(part.id)) return;
+        break;
+      case "finish":
+        if (droppedCalls > 0 && part.finishReason.unified === "tool-calls") {
+          controller.enqueue({ ...part, finishReason: { ...part.finishReason, unified: "stop" } });
+          return;
+        }
+        break;
+    }
+    controller.enqueue(part);
+  };
+  return {
+    /** Новая попытка: шаги прежней стёрты — всё сначала. */
+    reset() {
+      parts = [];
+      garbled = false;
+      droppedCalls = 0;
+      hinted = false;
+      textAt.clear();
+      open.clear();
+      droppedIds.clear();
+    },
+    /** Модель попытки под присмотром: каждый запрос — новый шаг. */
+    wrap(model) {
+      if (typeof model === "string") return model;
+      return wrapLanguageModel3({
+        model,
+        middleware: {
+          specificationVersion: "v4",
+          wrapStream: async ({ doStream }) => {
+            const result = await doStream();
+            parts.push({ type: "step-start" });
+            return { ...result, stream: result.stream.pipeThrough(new TransformStream({ transform })) };
+          }
+        }
+      });
+    },
+    /** Срыв уже замечен в этой попытке: нового шага не нужно. */
+    garbled: () => garbled,
+    /** Сколько вызовов отброшено до запуска. */
+    droppedCalls: () => droppedCalls,
+    /** Части ответа для правила при сохранении: отброшенный вызов — на своём месте, в конце. */
+    forCut: (saved) => droppedCalls > 0 ? [...saved, DROPPED_CALL] : saved,
+    /** Заглушка отброшенного вызова из `forCut`: в запись не идёт. */
+    isDroppedCall: (part) => part === DROPPED_CALL
+  };
+}
+var isToolPart6 = (part) => part.type.startsWith("tool-") || part.type === "dynamic-tool";
+function stepsOf(parts) {
+  const steps = [];
+  let current = { from: 0, to: 0, texts: [] };
+  parts.forEach((part, partIndex) => {
+    if (part.type === "step-start") {
+      current.to = partIndex;
+      steps.push(current);
+      current = { from: partIndex, to: partIndex, texts: [] };
+    } else if (part.type === "text") current.texts.push({ partIndex, visible: withoutCodeAndQuotes(part.text) });
+  });
+  current.to = parts.length;
+  steps.push(current);
+  return steps.filter((step) => step.texts.length > 0);
+}
+function garbleInStep(parts, step, markers) {
+  const roles = markers.filter((marker) => marker.kind === "role");
+  const role = roles.find((marker) => finishedBefore(step.texts, marker));
+  if (!role) return null;
+  const after = (marker) => byPlace(marker, role) > 0;
+  const tokens2 = markers.filter((marker) => marker.kind !== "role");
+  const gluedAfter = () => textAfter(step.texts, role).some((text) => GLUED_SENTENCES.test(text));
+  const others = /* @__PURE__ */ new Set();
+  if (role.roleToken) {
+    if (tokens2.some((marker) => !after(marker))) others.add("think");
+    if (roles.some(after) || gluedAfter()) others.add("restart");
+  } else {
+    if (tokens2.length > 0) others.add("think");
+    if (roles.some(after)) others.add("restart");
+    if (role.bareRole.glued) {
+      if (gluedAfter()) others.add("restart");
+      if (parts.slice(role.partIndex + 1, step.to).some(isToolPart6)) others.add("tool");
+    }
+  }
+  if (others.size === 0) return null;
+  const closeThinks = markers.filter((marker) => marker.kind === "close-think" && !after(marker));
+  const anchor = closeThinks.length >= 2 ? closeThinks[0] : role;
+  const signs2 = /* @__PURE__ */ new Set(["role", ...others]);
+  return { partIndex: anchor.partIndex, offset: anchor.offset, signs: SIGN_ORDER.filter((sign) => signs2.has(sign)) };
+}
+var byPlace = (a, b) => a.partIndex - b.partIndex || a.offset - b.offset;
+function textAfter(texts, anchor) {
+  return texts.flatMap(
+    (text) => text.partIndex < anchor.partIndex ? [] : [text.partIndex === anchor.partIndex ? text.visible.slice(anchor.offset) : text.visible]
+  );
+}
+function markersIn(text, earlier) {
+  const { partIndex, visible } = text;
+  const markers = [];
+  const hasTextBefore = (offset) => visibleBefore(earlier, visible, offset) !== "";
+  const roleTokens = /* @__PURE__ */ new Set();
+  for (const match of visible.matchAll(TOKEN_ROLE_LINE)) {
+    roleTokens.add(match.index);
+    if (hasTextBefore(match.index)) markers.push({ partIndex, offset: match.index, kind: "role", roleToken: true });
+  }
+  for (const match of visible.matchAll(TEMPLATE_TOKEN)) {
+    if (roleTokens.has(match.index) || !hasTextBefore(match.index)) continue;
+    markers.push({ partIndex, offset: match.index, kind: match[0] === "</think>" ? "close-think" : "token" });
+  }
+  for (const match of visible.matchAll(ROLE_LINE)) {
+    if (!hasTextBefore(match.index)) continue;
+    const name = match[1];
+    const glued = /[А-ЯЁа-яё]/.test(visible[match.index + name.length] ?? "");
+    markers.push({ partIndex, offset: match.index, kind: "role", bareRole: { name, glued } });
+  }
+  return markers.sort(byPlace);
+}
+function finishedBefore(texts, marker) {
+  const at = texts.findIndex((text) => text.partIndex === marker.partIndex);
+  return FINISHED.test(visibleBefore(texts.slice(0, at), texts[at].visible, marker.offset));
+}
+function visibleBefore(earlier, visible, offset) {
+  const own = visible.slice(0, offset).replace(TRAILING_TOKENS, "");
+  if (own) return own;
+  for (let index = earlier.length - 1; index >= 0; index -= 1) {
+    const text = earlier[index].visible.replace(TRAILING_TOKENS, "");
+    if (text) return text;
+  }
+  return "";
+}
+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;
+      return " ".repeat(line.length);
+    }
+    if (opener) {
+      fence = opener;
+      return " ".repeat(line.length);
+    }
+    if (/^(?: {4}|\t)/.test(line) || /^\s*>/.test(line)) return " ".repeat(line.length);
+    return line.replace(/(`+)[^`\n]*?\1/g, (code) => " ".repeat(code.length));
+  }).join("\n");
+}
+
 // src/agent-run/build-model-request.ts
 async function buildModelRequest(input) {
   const found = findModel(input.catalog, input.modelId, input.providerId);
@@ -3684,7 +4066,7 @@ async function buildModelRequest(input) {
   });
   const tools = input.tools ? sortToolsByName(input.tools) : void 0;
   const sendable = input.switchableTools ? withSwitchedOffCallsAsText(sendableHistory(input.history), input.switchableTools, tools) : sendableHistory(input.history);
-  const noted = withChannelNotes(withModeNotes(withBurstsJoined(withCorrectionsJoined(sendable)), input.modeNotes));
+  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, {
     modelId: profile.id,
@@ -3720,7 +4102,7 @@ async function buildModelRequest(input) {
   };
 }
 function sendableHistory(history) {
-  return withoutUndelivered(history).filter((message) => (message.role !== "assistant" || hasAnswerContent(message.parts)) && !isStateMessage(message)).map(withAssistantFilesAsText).map((message) => {
+  return withoutGarbledTails(withoutUndelivered(history)).filter((message) => (message.role !== "assistant" || hasAnswerContent(message.parts)) && !isStateMessage(message)).map(withAssistantFilesAsText).map((message) => {
     const closed = message.role === "assistant" ? closeHangingToolCalls(message.parts) : message.parts;
     const parts = withoutLoneSurrogatesInParts(closed);
     return parts === message.parts ? message : { ...message, parts };
@@ -3768,7 +4150,7 @@ function withoutLoneSurrogatesDeep(value) {
 }
 function withRequestWatch(model, provider, watch) {
   if (!watch || typeof model === "string") return model;
-  return wrapLanguageModel3({
+  return wrapLanguageModel4({
     model,
     middleware: {
       specificationVersion: "v4",
@@ -3788,7 +4170,7 @@ function withRequestWatch(model, provider, watch) {
   });
 }
 function withTransientRetries(model, context) {
-  return typeof model === "string" ? model : wrapLanguageModel3({ model, middleware: createTransientRetryMiddleware(context) });
+  return typeof model === "string" ? model : wrapLanguageModel4({ model, middleware: createTransientRetryMiddleware(context) });
 }
 function withLastMessageMark(messages, options2) {
   if (!options2 || messages.length === 0) return messages;
@@ -4019,8 +4401,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 }) };
@@ -4029,6 +4417,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)) {
@@ -5052,6 +5444,10 @@ function withTextAt(parts, index, text) {
 function createShownSteps() {
   let steps = 0;
   let textSteps = [];
+  const resetsToText = (fromEnd) => {
+    const step = textSteps.at(-1 - fromEnd);
+    return step === void 0 || step === 0 ? null : steps - step + 1;
+  };
   return {
     observe(chunk) {
       if (chunk.type === "start-step") steps += 1;
@@ -5062,10 +5458,9 @@ function createShownSteps() {
       }
     },
     /** Сколько шагов стереть с конца, чтобы убрать шаг последнего текста; `null` — текста на экране нет. */
-    resetsToLastText() {
-      const last = textSteps.at(-1);
-      return last === void 0 || last === 0 ? null : steps - last + 1;
-    }
+    resetsToLastText: () => resetsToText(0),
+    /** То же для текста `fromEnd`-го с конца (0 — последний); `null` — такого текста на экране нет. */
+    resetsToText
   };
 }
 function replacementChunks(corrected, index, resets, providerId) {
@@ -5531,6 +5926,7 @@ async function runTurn(turnInput, emitRaw) {
   const externalContent = createExternalContentWatch();
   const emitShown = (chunk) => {
     shownSteps?.observe(chunk);
+    screenSteps.observe(chunk);
     emitRaw(chunk);
     if (turnInput.liveDemos && externalContent.observe(chunk)) emitRaw(externalContentChunk());
   };
@@ -5538,6 +5934,7 @@ async function runTurn(turnInput, emitRaw) {
   const seenTexts = replyChecks && createSeenTexts();
   const heldText = replyChecks && (replyChecks.web === "hold" || (turnInput.channel ?? "web") !== "web") ? createHeldReplyText() : void 0;
   const shownSteps = replyChecks && createShownSteps();
+  const screenSteps = createShownSteps();
   const emitToClient = (chunk) => {
     for (const passed of heldText ? heldText.pass(chunk) : [chunk]) emitShown(passed);
   };
@@ -5572,6 +5969,7 @@ async function runTurn(turnInput, emitRaw) {
     }
   );
   const turnUsage = createTurnUsage();
+  const garbledTail = createGarbledTailGuard();
   const turnBudget = createTurnBudget(input.turnRules, { catalog: input.catalog, modelId: input.modelId, turnUsage });
   const messageUsage = () => {
     const spent = turnUsage.total();
@@ -5660,13 +6058,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);
@@ -5739,6 +6145,7 @@ async function runTurn(turnInput, emitRaw) {
             emit,
             turnUsage,
             turnBudget,
+            garbledTail,
             // Есть куда перейти при молчании — у того же провайдера оно не повторяется.
             repeatSilence: () => silenceTarget() === void 0,
             ...silenceSwitch.scope === "step" && switchedBySilence && {
@@ -5756,13 +6163,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;
@@ -5797,12 +6205,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;
@@ -5874,8 +6294,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 })
@@ -5942,6 +6362,15 @@ async function runTurn(turnInput, emitRaw) {
     const failed = input.abortSignal.aborted || errors.length > 0;
     const closing = !failed && pendingHumanInput(savedParts, input.waitingWidgets).length > 0 && (closure !== void 0 || await chatClosedNow());
     let parts = failed || closing ? closeHangingToolCalls(denyPendingApprovals(savedParts, INTERRUPTED_REASON, RESULT_UNKNOWN_REASON), { notStarted: toolQueue.notStarted }) : savedParts;
+    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}`;
+    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));
+      if (!takeover.signal.aborted) showCutAnswer(parts, cut, garbled.textIndex, { heldText, screenSteps, providerId: answeredProviderId, emit: emitShown });
+      parts = cut;
+    } else if (findGarbledTail(garbledTail.forCut(parts))) logError(`[\u0445\u0432\u043E\u0441\u0442 \u043D\u0435 \u043E\u0431\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] ${garbleLog}`);
     const status = input.abortSignal.aborted ? "stopped" : errors.length > 0 ? "error" : pendingHumanInput(parts, input.waitingWidgets).length > 0 ? "awaiting_approval" : "complete";
     if (endTurns.hasText()) logError(`[endTurn] \u0447\u0430\u0442=${input.chatId} \u0433\u043E\u0442\u043E\u0432\u044B\u0439 \u0442\u0435\u043A\u0441\u0442 \u043D\u0435 \u043F\u043E\u043A\u0430\u0437\u0430\u043D: \u0445\u043E\u0434 \u043A\u043E\u043D\u0447\u0438\u043B\u0441\u044F \u0441\u043E \u0441\u0442\u0430\u0442\u0443\u0441\u043E\u043C ${status}`);
     const textIndex = lastTextIndex(parts);
@@ -6255,8 +6684,10 @@ async function openAttempt(input, attempt, attemptSignal) {
     return true;
   };
   const { noteAfterApprovals, ...modelRequest } = request;
+  attempt.garbledTail.reset();
   const result = streamText({
     ...modelRequest,
+    model: attempt.garbledTail.wrap(modelRequest.model),
     ...approval.toolApproval && { toolApproval: gateToolApproval(approval.toolApproval, () => toolsClosed) },
     // Попытке — остаток шагов хода.
     // Помощник встал на подтверждении человека — ход ждёт, модель основного агента его незаконченным не видит.
@@ -6264,6 +6695,7 @@ async function openAttempt(input, attempt, attemptSignal) {
     // Инструмент кончил ход: без текста — стоп сразу; с текстом — ещё шаг подставной модели, его держит только помощник
     // на подтверждении (ход ждёт человека). Потолок шагов и прочие стопы готовый текст не теряют.
     stopWhen: async (options2) => {
+      if (attempt.garbledTail.garbled()) return true;
       if (attempt.endTurns.requested()) {
         if (attempt.endTurns.hasText()) return helperAwaitsApproval(options2);
         attempt.endTurns.stopWithoutText();
@@ -6475,6 +6907,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 }
@@ -6599,6 +7032,19 @@ function withLastUserPart(history, part) {
   return history.map((message, position) => position === index ? { ...message, parts: [...message.parts, part] } : message);
 }
 var FINISH_RETRY_PAUSES_MS = [1e3, 3e3];
+function showCutAnswer(original, cut, anchor, screen) {
+  if (anchor === -1) return;
+  const textsAfter = original.slice(anchor + 1).filter((part) => part.type === "text").length;
+  if (screen.heldText?.holdsText()) {
+    if (textsAfter === 0 && lastTextIndex(cut) === anchor) {
+      for (const chunk of screen.heldText.release(cut[anchor].text)) screen.emit(chunk);
+      return;
+    }
+    for (const chunk of screen.heldText.release()) screen.emit(chunk);
+  }
+  const resets = screen.screenSteps.resetsToText(textsAfter);
+  for (const chunk of resets && replacementChunks(cut, anchor, resets, screen.providerId) || []) screen.emit(chunk);
+}
 async function finishWithRetries(storage, messageId, final, logError) {
   for (let attempt = 0; ; attempt += 1) {
     let failure;
@@ -6692,16 +7138,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],
@@ -6728,17 +7184,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);
@@ -6951,6 +7418,7 @@ function createChatEvents(logError = () => {
         listeners.delete(listener);
       };
     },
+    hasListeners: () => listeners.size > 0,
     emit(event) {
       for (const listener of [...listeners]) {
         try {
@@ -7033,9 +7501,9 @@ function editAnswerParts(parts, edit, uneditable) {
   return { ok: true, parts: textPlaced ? edited : [...edited, textPart] };
 }
 function toolCallIdOf(part) {
-  return isToolPart6(part) ? part.toolCallId : void 0;
+  return isToolPart7(part) ? part.toolCallId : void 0;
 }
-var isToolPart6 = (part) => part.type.startsWith("tool-") || part.type === "dynamic-tool";
+var isToolPart7 = (part) => part.type.startsWith("tool-") || part.type === "dynamic-tool";
 function toolNameOf2(part) {
   return part.type === "dynamic-tool" ? part.toolName : part.type.slice("tool-".length);
 }
@@ -7329,7 +7797,7 @@ var fireworksProvider = createFireworksProvider();
 
 // src/models/providers/openrouter.ts
 import { createOpenRouter } from "@openrouter/ai-sdk-provider";
-import { wrapLanguageModel as wrapLanguageModel4 } from "ai";
+import { wrapLanguageModel as wrapLanguageModel5 } from "ai";
 
 // src/models/providers/openrouter-cache-mark-limit.ts
 function openrouterCacheMarkLimit(providerModelId) {
@@ -7579,7 +8047,7 @@ function createOpenRouterProvider(options2 = {}) {
     createLanguageModel: (providerModelId, apiKey, requestOptions) => {
       const markLimit = openrouterCacheMarkLimit(providerModelId);
       const fetch = markLimit === void 0 ? requestOptions?.fetch : fetchWithCacheMarkLimit(requestOptions?.fetch, markLimit);
-      return wrapLanguageModel4({
+      return wrapLanguageModel5({
         model: createOpenRouter({ apiKey, fetch, ...connection }).chat(providerModelId, routingOptions),
         middleware: [
           openrouterRoutingMiddleware(routing),
@@ -9481,7 +9949,7 @@ function isPlainObject3(value) {
 }
 
 // src/memory/memory-after-answer.ts
-import { wrapLanguageModel as wrapLanguageModel5 } from "ai";
+import { wrapLanguageModel as wrapLanguageModel6 } from "ai";
 var DRAIN_WAIT_MS = 5e3;
 function createMemoryAfterAnswer({ memory, storage, catalog, env, logError, turnObserver }) {
   const running = /* @__PURE__ */ new Set();
@@ -9526,7 +9994,7 @@ function createMemoryAfterAnswer({ memory, storage, catalog, env, logError, turn
   };
 }
 function withRetries(model, context) {
-  return typeof model === "string" ? model : wrapLanguageModel5({ model, middleware: createTransientRetryMiddleware(context) });
+  return typeof model === "string" ? model : wrapLanguageModel6({ model, middleware: createTransientRetryMiddleware(context) });
 }
 
 // src/conversation/to-agent-chat-message.ts
@@ -10248,6 +10716,7 @@ function createTurnGate(hooks) {
       ...input.text !== void 0 && { text: input.text },
       ...input.messageId !== void 0 && { messageId: input.messageId },
       ...input.burstMessageIds && { burstMessageIds: [...input.burstMessageIds] },
+      ...input.unattended && { unattended: true },
       ...abandonedOf(input)
     });
     if (!decision) return TURN;
@@ -10280,6 +10749,7 @@ function createTurnGate(hooks) {
         ...input.messageId !== void 0 && { messageId: input.messageId },
         ...input.text !== void 0 && { text: input.text },
         ...input.burstMessageIds && { burstMessageIds: [...input.burstMessageIds] },
+        ...input.unattended && { unattended: true },
         reason,
         ...abandonedOf(input)
       });
@@ -10670,6 +11140,8 @@ var InvalidWidgetAnswerError = class extends Error {
     this.name = "InvalidWidgetAnswerError";
   }
 };
+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`);
@@ -10867,6 +11339,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();
@@ -10913,7 +11386,9 @@ function createChatService(input) {
   const steersInFlight = /* @__PURE__ */ new Map();
   const startingByChat = /* @__PURE__ */ new Map();
   const burstWaits = createBurstWaits();
-  const turnLeases = createChatTurnLeases({ storage, holder: crypto.randomUUID(), logError });
+  const copyId = crypto.randomUUID();
+  const turnLeases = createChatTurnLeases({ storage, holder: copyId, logError });
+  const burstSweeps = /* @__PURE__ */ new Set();
   const burstWrites = /* @__PURE__ */ new Map();
   const chatToolQueues = /* @__PURE__ */ new Map();
   let staleSweep = null;
@@ -11540,6 +12015,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) },
@@ -11661,7 +12137,15 @@ function createChatService(input) {
     steeringTurn = steering.begin(chatId, answerId);
     if (stopsWhileStarting.delete(chatId)) registry.abort(chatId);
     const turnEvent = { ownerId: chat.ownerId, chatId, messageId: answerId, trigger, channel };
-    chatEvents.emit({ type: "turn-started", ...turnEvent, ...launch.deliveredByApp && { deliveredByApp: true } });
+    chatEvents.emit({
+      type: "turn-started",
+      ...turnEvent,
+      ...launch.deliveredByApp && { deliveredByApp: true },
+      ...launch.unattended && { unattended: true }
+    });
+    if (launch.unattended && chatEvents.hasListeners?.() === false) {
+      logError(`\u0425\u043E\u0434 \u0431\u0435\u0437 \u0432\u044B\u0437\u043E\u0432\u0430 \u043D\u0430 \u043F\u0430\u0447\u043A\u0443 \u0447\u0430\u0442\u0430 ${chatId}: \u043D\u0430 \u0441\u043E\u0431\u044B\u0442\u0438\u044F \u0447\u0430\u0442\u0430 \u043D\u0438\u043A\u0442\u043E \u043D\u0435 \u043F\u043E\u0434\u043F\u0438\u0441\u0430\u043D \u2014 \u043E\u0442\u0432\u0435\u0442 \u0431\u0443\u0434\u0435\u0442 \u0442\u043E\u043B\u044C\u043A\u043E \u0432 \u0438\u0441\u0442\u043E\u0440\u0438\u0438`);
+    }
     launch.onStarted?.({ answerId, finished });
     liveAnswerIds.add(answerId);
     const slot = startingSlots.get(chatId);
@@ -11779,6 +12263,7 @@ function createChatService(input) {
           await assertStillOpen(chatId);
           const earlier = await storage.getMessage(message.id);
           if (earlier?.chatId === chatId && earlier.role === "user") return earlier;
+          if (sendOptions?.answerAfterRestart) await savingPendingBurst(userId, chatId, message.id, now().getTime() + quietMs, sendOptions.page);
           const written = await writingHumanMessage(userId, chatId, await currentBranch(chatId), message, text, files, sendOptions, { quietMs });
           chatEvents.emit({ type: "message-added", ownerId: userId, chatId, messageId: written.id });
           return written;
@@ -11797,11 +12282,11 @@ function createChatService(input) {
       return true;
     };
   }
-  async function answeringBurst(userId, chatId, question2, sendOptions) {
+  async function answeringBurst(userId, chatId, questionId, page, unattended = false) {
     const otherCopy = waitingForOtherCopy(chatId);
     for (; ; ) {
       if (closing) throw new ChatBusyError(chatId);
-      const verdict = burstVerdict(await currentBranch(chatId), question2.id, now().getTime());
+      const verdict = burstVerdict(await currentBranch(chatId), questionId, now().getTime());
       if (verdict.kind === "skip") return null;
       if (verdict.kind === "wait") {
         if (closing) throw new ChatBusyError(chatId);
@@ -11818,16 +12303,20 @@ function createChatService(input) {
       const burstMessageIds = verdict.burst.map((message) => message.id);
       try {
         const stream = await startingTurn(
-          { userId, chat, action: "send", text: burstText(verdict.burst), messageId: question2.id, burstMessageIds },
+          { userId, chat, action: "send", text: burstText(verdict.burst), messageId: questionId, burstMessageIds, ...unattended && { unattended: true } },
           async (pass) => {
             const branch = await currentBranch(chatId);
-            if (burstVerdict(branch, question2.id, now().getTime()).kind !== "start") return null;
-            if (pass.kind === "hold") return heldTurn(userId, chatId, question2.id);
+            if (burstVerdict(branch, questionId, now().getTime()).kind !== "start") return null;
+            if (pass.kind === "hold") return unattended ? (heldTurn(userId, chatId, questionId), "unattended") : heldTurn(userId, chatId, questionId);
             takeTurnSlot(userId, chatId);
-            return startAnswer("send", userId, chatId, branch, sendOptions?.page, void 0, void 0, replyOf(pass));
+            if (!unattended) return startAnswer("send", userId, chatId, branch, page, void 0, void 0, replyOf(pass));
+            const reply = replyOf(pass);
+            await launchTurn(userId, chatId, branch, { parentId: branch.at(-1).id, page, action: "send", detached: true, unattended: true, ...reply !== void 0 && { reply } });
+            return "unattended";
           },
           (result) => result === null ? "busy" : void 0
         );
+        if (stream === "unattended") return null;
         return stream && viewerStream(userId, chat, {}, async () => stream);
       } catch (error) {
         if (error instanceof ChatBusyError && !closing && localTurnOf(chatId)) continue;
@@ -11836,6 +12325,115 @@ function createChatService(input) {
       }
     }
   }
+  const keepsPendingBursts = Boolean(storage.savePendingBurst && storage.takeAbandonedBursts && storage.renewPendingBurst && storage.removePendingBurst);
+  async function savingPendingBurst(ownerId, chatId, messageId, dueAt, page) {
+    if (!keepsPendingBursts) return;
+    await storage.savePendingBurst({
+      chatId,
+      ownerId,
+      messageId,
+      dueAt: new Date(dueAt).toISOString(),
+      holder: copyId,
+      heldUntil: new Date(dueAt + BURST_HOLD_MS).toISOString(),
+      ...page && { page }
+    });
+  }
+  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, heldUntil }).then(
+        (held) => {
+          if (!held) clearInterval(timer);
+        },
+        (error) => logError(`\u0423\u0434\u0435\u0440\u0436\u0430\u043D\u0438\u0435 \u043F\u0430\u0447\u043A\u0438 \u0447\u0430\u0442\u0430 ${chatId} \u043D\u0435 \u043F\u0440\u043E\u0434\u043B\u0438\u043B\u043E\u0441\u044C: ${error instanceof Error ? error.message : String(error)}`)
+      );
+    }, BURST_HOLD_RENEW_MS);
+    timer.unref?.();
+    return () => clearInterval(timer);
+  }
+  const burstWaitsForNextSweep = (error) => error instanceof ChatBusyError || error instanceof TooManyTurnsError;
+  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, burst.holder ?? copyId);
+    const answering = burstWaits.holding(chatId, () => answeringBurst(ownerId, chatId, questionId, page, unattended)).finally(stopRenewing);
+    void answering.then(
+      () => true,
+      (error) => !burstWaitsForNextSweep(error)
+    ).then((decided) => {
+      if (decided)
+        return storage.removePendingBurst(chatId, questionId).catch((error) => logError(`\u0417\u0430\u043F\u0438\u0441\u044C \u043F\u0430\u0447\u043A\u0438 \u0447\u0430\u0442\u0430 ${chatId} \u043D\u0435 \u0441\u043D\u044F\u043B\u0430\u0441\u044C: ${error instanceof Error ? error.message : String(error)}`));
+    });
+    return answering;
+  }
+  let burstDecisions = 0;
+  const burstDecisionWaiters = /* @__PURE__ */ new Set();
+  const burstDecisionFreed = () => new Promise((resolve) => burstDecisionWaiters.add(resolve));
+  function releasingBurstDecision() {
+    burstDecisions--;
+    for (const waiter of [...burstDecisionWaiters]) {
+      burstDecisionWaiters.delete(waiter);
+      waiter();
+    }
+  }
+  function reportingAbandonedBurst(chatId, error) {
+    if (burstWaitsForNextSweep(error)) return;
+    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 () => {
+      for (; ; ) {
+        if (closing) return;
+        const free = BURST_SWEEP_LIMIT - burstDecisions;
+        if (free <= 0) {
+          await burstDecisionFreed();
+          continue;
+        }
+        const heldUntil = new Date(now().getTime() + BURST_HOLD_MS).toISOString();
+        const taken = await storage.takeAbandonedBursts({ ...take, holder: copyId, heldUntil, limit: free });
+        if (taken.length === 0) return;
+        for (const burst of taken) {
+          burstDecisions++;
+          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));
+    burstSweeps.add(sweep);
+    return sweep;
+  }
   async function stoppingPendingBurst(userId, chatId) {
     if (!burstWaits.has(chatId) && !isBurstPending(await currentBranch(chatId), now().getTime())) return false;
     try {
@@ -12261,7 +12859,13 @@ function createChatService(input) {
       }).catch(() => {
       });
       const question2 = await recording;
-      const turn = burstWaits.holding(chatId, () => answeringBurst(userId, chatId, question2, burstOptions));
+      const turn = answeringRecordedBurst(
+        userId,
+        chatId,
+        question2.id,
+        burstOptions?.page,
+        burstOptions?.answerAfterRestart ? { kept: true, dueAt: Date.parse(question2.createdAt) + quietMs } : { kept: false }
+      );
       turn.catch(() => {
       });
       return { messageId: question2.id, turn };
@@ -12546,9 +13150,15 @@ function createChatService(input) {
     },
     async recoverInterruptedAnswers(recoverOptions) {
       await afterTurn?.recoverPending(liveAnswerIds);
-      const [count] = await Promise.all([recoverAnswersOnStart(recoverOptions?.soleServer === true), options2.background?.recover()]);
+      const soleServer = recoverOptions?.soleServer === true;
+      const [count] = await Promise.all([recoverAnswersOnStart(soleServer), options2.background?.recover()]);
+      await sweepingBursts(soleServer ? { abandonedBefore: FAR_FUTURE_ISO, exceptHolder: copyId } : { abandonedBefore: now().toISOString() });
       return count;
     },
+    async tickBursts() {
+      burstWaits.wakeAll();
+      await sweepingBursts({ abandonedBefore: now().toISOString() });
+    },
     async closeChat({ ownerId, chatId, code, message }) {
       const closed = normalizeChatClosure({ code, message });
       await changeClosure(await ownChat(ownerId, chatId), closed);
@@ -12576,6 +13186,7 @@ function createChatService(input) {
       burstWaits.cancelAll();
       try {
         await sweeping;
+        while (burstSweeps.size > 0) await Promise.allSettled([...burstSweeps]);
         while (startingWork.size > 0) await Promise.allSettled([...startingWork]);
         const unfinished = await liveTurns.drain(waitForAnswersMs);
         await burstWaits.settled();
@@ -12614,7 +13225,7 @@ function createChatService(input) {
       const next = () => {
         if (sweep.stopped) return;
         sweep.timer = setTimeout(() => {
-          sweep.running = Promise.all([recoverStaleAnswers(), afterTurn?.recoverPending(liveAnswerIds)]).then(() => void 0).catch(
+          sweep.running = Promise.all([recoverStaleAnswers(), afterTurn?.recoverPending(liveAnswerIds), sweepingBursts({ abandonedBefore: now().toISOString() })]).then(() => void 0).catch(
             (failure) => logError(`\u041F\u0440\u043E\u0432\u0435\u0440\u043A\u0430 \u0431\u0440\u043E\u0448\u0435\u043D\u043D\u044B\u0445 \u043E\u0442\u0432\u0435\u0442\u043E\u0432 \u043D\u0435 \u0443\u0434\u0430\u043B\u0430\u0441\u044C: ${failure instanceof Error ? failure.message : "\u043D\u0435\u0438\u0437\u0432\u0435\u0441\u0442\u043D\u0430\u044F \u043E\u0448\u0438\u0431\u043A\u0430"}`)
           ).finally(() => {
             sweep.running = void 0;
@@ -12731,6 +13342,7 @@ function createChatService(input) {
           modelSilence,
           logError,
           ...providerFallback !== void 0 && { providerFallback },
+          providerOutages,
           ...options2.turnObserver && { turnObserver: options2.turnObserver },
           ...options2.limits && { assertWithinLimit: () => assertWithinSpendingLimit(ownerId, chatId) }
         });
@@ -12740,6 +13352,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);
@@ -12899,6 +13512,8 @@ export {
   isCorrection,
   BURST_PART_TYPE,
   DEFAULT_BURST_QUIET_MS,
+  BURST_HOLD_MS,
+  BURST_SWEEP_LIMIT,
   isBurstMessage,
   RELEASED_ANSWER_ALIVE_AT,
   aliveAtByLocalClock,
@@ -12999,4 +13614,4 @@ export {
   InvalidWidgetAnswerError,
   createChatService
 };
-//# sourceMappingURL=chunk-7M7M7DAN.js.map
+//# sourceMappingURL=chunk-KAG3QTZC.js.map