@ykurilov/agent-chat-core 0.55.0 → 0.57.0

package/dist/{chunk-PWW3R3VL.js → chunk-BS2HDKZB.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;
@@ -41,7 +41,8 @@ var BUILT_IN_USAGE_SOURCES = [
   "judge",
   "first_message",
   "voice_input",
-  "voice_polish"
+  "voice_polish",
+  "mcp_tool"
 ];
 
 // src/conversation/branches.ts
@@ -1717,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 } };
 }
@@ -1825,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);
@@ -2284,6 +2291,57 @@ function jsonBytes(value) {
   }
 }
 
+// src/agent-run/agent-viewer.ts
+var AgentViewerError = class extends Error {
+  constructor(message, options2) {
+    super(message, options2);
+    this.name = "AgentViewerError";
+  }
+};
+async function resolveAgentViewer(source, input) {
+  input.abortSignal.throwIfAborted();
+  let viewer;
+  try {
+    viewer = await Promise.race([
+      Promise.resolve().then(() => source(input)),
+      new Promise((_, reject) => input.abortSignal.addEventListener("abort", () => reject(input.abortSignal.reason), { once: true }))
+    ]);
+  } catch (error) {
+    if (input.abortSignal.aborted) throw error;
+    throw new AgentViewerError(`agent.viewer \u0431\u0440\u043E\u0441\u0438\u043B\u0430: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+  }
+  if (typeof viewer !== "object" || viewer === null || Array.isArray(viewer)) throw new AgentViewerError("agent.viewer \u0432\u0435\u0440\u043D\u0443\u043B\u0430 \u043D\u0435 \u043E\u0431\u044A\u0435\u043A\u0442");
+  return Object.freeze({ ...viewer });
+}
+function viewerInput(turn) {
+  const ownerId = turn.ownerId ?? "";
+  return {
+    userId: turn.staff?.id ?? ownerId,
+    chatId: turn.chatId,
+    ownerId,
+    messageId: turn.messageId,
+    chat: structuredClone({ ...turn.chatData && { data: turn.chatData } }),
+    ...turn.subject && { subject: structuredClone(turn.subject) },
+    channel: turn.channel ?? "web",
+    audience: turn.audience,
+    ...turn.staff && { staff: structuredClone(turn.staff) },
+    abortSignal: turn.abortSignal
+  };
+}
+var VIEWER_OUTSIDE_TURN_TIMEOUT_MS = 1e4;
+async function resolveViewerOutsideTurn(source, turn, signal) {
+  const deadline = new AbortController();
+  const timer = setTimeout(
+    () => deadline.abort(new AgentViewerError(`agent.viewer \u043D\u0435 \u043E\u0442\u0432\u0435\u0442\u0438\u043B\u0430 \u0437\u0430 ${VIEWER_OUTSIDE_TURN_TIMEOUT_MS / 1e3} \u0441`)),
+    VIEWER_OUTSIDE_TURN_TIMEOUT_MS
+  );
+  try {
+    return await resolveAgentViewer(source, viewerInput({ ...turn, abortSignal: signal ? AbortSignal.any([signal, deadline.signal]) : deadline.signal }));
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
 // src/helpers/run-helper.ts
 import { generateText as generateText2, stepCountIs as stepCountIs2 } from "ai";
 
@@ -2807,7 +2865,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;
@@ -3483,6 +3541,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) {
@@ -3608,6 +3697,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);
@@ -3632,7 +4013,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,
@@ -3668,7 +4049,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 };
@@ -3716,7 +4097,7 @@ function withoutLoneSurrogatesDeep(value) {
 }
 function withRequestWatch(model, provider, watch) {
   if (!watch || typeof model === "string") return model;
-  return wrapLanguageModel3({
+  return wrapLanguageModel4({
     model,
     middleware: {
       specificationVersion: "v4",
@@ -3736,7 +4117,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;
@@ -5000,6 +5381,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;
@@ -5010,10 +5395,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) {
@@ -5436,6 +5820,7 @@ async function freezeTurnContext(input, turn, base, place) {
         channel: input.channel ?? "web",
         audience: input.group ? "group" : "private",
         ...input.staff && { staff: structuredClone(input.staff) },
+        ...turn.viewer && { viewer: turn.viewer },
         modelId: input.modelId,
         providerId: input.providerId
       }
@@ -5478,6 +5863,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());
   };
@@ -5485,6 +5871,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);
   };
@@ -5519,6 +5906,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();
@@ -5577,10 +5965,12 @@ async function runTurn(turnInput, emitRaw) {
     let errorKind;
     let providerId = input.providerId;
     let answeredProviderId = input.providerId;
+    let viewer;
     try {
       const { history: historySource } = input;
       const fullHistory = typeof historySource === "function" ? await historySource() : historySource;
       const branchState = input.appState ?? foldAppState(fullHistory);
+      viewer = input.viewer && await resolveAgentViewer(input.viewer, viewerInput({ ...input, audience: input.group ? "group" : "private" }));
       const prepared = input.prepareTurn && await input.prepareTurn({ state: branchState, abortSignal: input.abortSignal });
       const turnNotices = prepared && prepared.notices.length > 0 ? prepared.notices : void 0;
       const stateBase = prepared?.state ?? branchState;
@@ -5596,10 +5986,11 @@ async function runTurn(turnInput, emitRaw) {
       const frozenOfTurn = await frozenContextForTurn(input, {
         history: answer.request().history,
         answer: resume?.message ?? fullHistory.find((message) => message.id === messageId),
-        state: publicAppState(appState.values())
+        state: publicAppState(appState.values()),
+        ...viewer && { viewer }
       });
       const frozen = turnNotices && frozenOfTurn.fresh ? { ...frozenOfTurn, data: { ...frozenOfTurn.data, notices: turnNotices } } : frozenOfTurn;
-      let resumeNote = resume && !resume.replay && !frozen.fresh ? await resumeNoteForTurn(input, { history: answer.request().history, answer: resume.message, state: publicAppState(appState.values()) }) : void 0;
+      let resumeNote = resume && !resume.replay && !frozen.fresh ? await resumeNoteForTurn(input, { history: answer.request().history, answer: resume.message, state: publicAppState(appState.values()), ...viewer && { viewer } }) : void 0;
       if (resume && turnNotices && !frozen.fresh) {
         const seen = latestFrozenContextOf(resume.message.parts);
         if (seen) resumeNote = { ...resumeNote ?? { blocks: seen.blocks, sent: { changed: [], removed: [] }, base: messageId }, notices: turnNotices };
@@ -5629,7 +6020,7 @@ async function runTurn(turnInput, emitRaw) {
       if (resume && !resume.replay) {
         const continued = helpersToContinue(resume.message.parts);
         if (continued.length > 0) {
-          await continueHelpers(input, continued, { toolQueue, dataChanges, appEvents, chatClosure, appState, emit, logError });
+          await continueHelpers(input, continued, { ...viewer && { viewer }, toolQueue, dataChanges, appEvents, chatClosure, appState, emit, logError });
           const parts2 = await saver.snapshot();
           answer.update(parts2, { modelId, providerId: answeredProviderId });
           mainLoopWaits = input.abortSignal.aborted || pendingHumanInput(parts2, input.waitingWidgets).length > 0;
@@ -5671,6 +6062,7 @@ async function runTurn(turnInput, emitRaw) {
             steps: { done: stepsDone, max: maxSteps, beforeResume: stepsBeforeResume },
             historyRewritten,
             frozenContext: frozen.data,
+            ...viewer && { viewer },
             toolQueue,
             endTurns,
             browser,
@@ -5682,6 +6074,7 @@ async function runTurn(turnInput, emitRaw) {
             emit,
             turnUsage,
             turnBudget,
+            garbledTail,
             // Есть куда перейти при молчании — у того же провайдера оно не повторяется.
             repeatSilence: () => silenceTarget() === void 0,
             ...silenceSwitch.scope === "step" && switchedBySilence && {
@@ -5853,7 +6246,8 @@ async function runTurn(turnInput, emitRaw) {
       }
     } catch (error2) {
       if (!input.abortSignal.aborted) {
-        errorKind = classifyProviderError(error2, void 0);
+        if (error2 instanceof AgentViewerError) logError(`[agent.viewer] \u0447\u0430\u0442=${input.chatId} \u0445\u043E\u0434 \u043D\u0435 \u043D\u0430\u0447\u0430\u0442: ${error2.message}`);
+        errorKind = error2 instanceof AgentViewerError ? "other" : classifyProviderError(error2, void 0);
         errors = [{ type: "error", errorText: errorKind }];
       }
     }
@@ -5884,6 +6278,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);
@@ -6197,8 +6600,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) },
     // Попытке — остаток шагов хода.
     // Помощник встал на подтверждении человека — ход ждёт, модель основного агента его незаконченным не видит.
@@ -6206,6 +6611,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();
@@ -6462,6 +6868,7 @@ function turnToolsModel(input, found, turn) {
     ...input.subject && { subject: input.subject },
     chat: { ...input.chatData && { data: input.chatData } },
     ...input.staff && { staff: input.staff },
+    ...turn.viewer && { viewer: turn.viewer },
     ...input.closeChat && { closeChat: turn.chatClosure.request },
     // Инструменту — только чтение и запись: конец записи и служебные ключи — дело ядра.
     state: { get: turn.appState.get, set: turn.appState.set, unset: turn.appState.unset }
@@ -6540,6 +6947,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;
@@ -6892,6 +7312,7 @@ function createChatEvents(logError = () => {
         listeners.delete(listener);
       };
     },
+    hasListeners: () => listeners.size > 0,
     emit(event) {
       for (const listener of [...listeners]) {
         try {
@@ -6974,9 +7395,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);
 }
@@ -7270,7 +7691,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) {
@@ -7520,7 +7941,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),
@@ -9422,7 +9843,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();
@@ -9467,7 +9888,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
@@ -9717,7 +10138,7 @@ function createCompactionService(options2) {
         chatId,
         model,
         instructions: await instructionsOf(chat),
-        tools: resolveTools(model, chat, chatId, ownerId),
+        tools: await resolveTools(model, chat, chatId, ownerId, branch, signal),
         ...options2.switchableTools && { switchableTools: options2.switchableTools },
         ...observation(ownerId, answerId),
         history,
@@ -9764,19 +10185,26 @@ function createCompactionService(options2) {
   function observation(ownerId, answerId) {
     return options2.turnObserver ? { observe: { observer: options2.turnObserver, ownerId, messageId: answerId ?? null } } : {};
   }
-  function resolveTools(model, chat, chatId, ownerId) {
-    const { tools } = options2.agent;
+  async function resolveTools(model, chat, chatId, ownerId, branch, signal) {
+    const { tools, viewer: viewerSource } = options2.agent;
     if (typeof tools !== "function") return tools;
     const subject = chat ? subjectOfChat(chat) : void 0;
+    const chatData = chat ? chatDataOfInput(chat) : void 0;
+    const { channel, group } = turnChannelOf(branch);
+    const audience = group ? "group" : "private";
+    const viewer = viewerSource && await resolveViewerOutsideTurn(viewerSource, { chatId, ownerId, messageId: "", ...chatData && { chatData }, ...subject && { subject }, channel, audience }, signal);
     return tools({
       profile: findModel(catalog, model.modelId, model.providerId).profile,
       providerId: model.providerId,
       chatId,
       ownerId,
       place: null,
+      channel,
+      audience,
       notifyDataChanged: (change) => logError(`\u0418\u043D\u0441\u0442\u0440\u0443\u043C\u0435\u043D\u0442 \u0441\u043E\u043E\u0431\u0449\u0438\u043B \u043E\u0431 \u0438\u0437\u043C\u0435\u043D\u0435\u043D\u0438\u0438 \u0434\u0430\u043D\u043D\u044B\u0445 \xAB${String(change?.tag)}\xBB \u0432\u043E \u0432\u0440\u0435\u043C\u044F \u0441\u0436\u0430\u0442\u0438\u044F \u0447\u0430\u0442\u0430 ${chatId}: \u0441\u043E\u043E\u0431\u0449\u0435\u043D\u0438\u0435 \u043D\u0435 \u043E\u0442\u043F\u0440\u0430\u0432\u043B\u0435\u043D\u043E`),
       ...subject && { subject },
-      chat: { ...chat && chatDataOfInput(chat) && { data: chatDataOfInput(chat) } }
+      chat: { ...chatData && { data: chatData } },
+      ...viewer && { viewer }
     });
   }
   return {
@@ -9853,7 +10281,7 @@ function createCompactionService(options2) {
           chatId,
           model,
           instructions: await instructionsOf(chat),
-          tools: resolveTools(model, chat, chatId, ownerId),
+          tools: await resolveTools(model, chat, chatId, ownerId, history, abortSignal),
           ...options2.switchableTools && { switchableTools: options2.switchableTools },
           ...observation(ownerId, answerId),
           history: [...history, { id: `${chatId}-answer-steps`, role: "assistant", parts: steps }],
@@ -10182,6 +10610,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;
@@ -10214,6 +10643,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)
       });
@@ -10604,6 +11034,7 @@ var InvalidWidgetAnswerError = class extends Error {
     this.name = "InvalidWidgetAnswerError";
   }
 };
+var FAR_FUTURE_ISO = "9999-12-31T23:59:59.999Z";
 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`);
@@ -10847,7 +11278,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;
@@ -11595,7 +12028,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);
@@ -11713,6 +12154,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;
@@ -11731,11 +12173,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);
@@ -11752,16 +12194,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;
@@ -11770,6 +12216,85 @@ 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) {
+    const timer = setInterval(() => {
+      const heldUntil = new Date(Math.max(now().getTime(), dueAt) + BURST_HOLD_MS).toISOString();
+      storage.renewPendingBurst({ chatId, messageId, holder: copyId, 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);
+    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}`);
+  }
+  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) {
+          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);
+        }
+      }
+    })().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 {
@@ -12195,7 +12720,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 };
@@ -12480,9 +13011,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);
@@ -12510,6 +13047,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();
@@ -12548,7 +13086,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;
@@ -12632,6 +13170,9 @@ function createChatService(input) {
         const choice = effectiveChoiceOfChat(options2.catalog, env, chat, defaultChoice);
         const found = findModel(options2.catalog, choice.modelId, choice.providerId);
         const subject = subjectOfChat(chat);
+        const { channel, group } = turnChannelOf(await loadCurrentBranch(storage, chatId));
+        const audience = group ? "group" : "private";
+        const viewer = options2.agent.viewer && await resolveViewerOutsideTurn(options2.agent.viewer, { chatId, ownerId, messageId: "", chatData: chatDataOfInput(chat), subject, channel, audience });
         const model = {
           profile: found.profile,
           providerId: found.provider.id,
@@ -12641,11 +13182,12 @@ function createChatService(input) {
           // Вкладки у фоновой задачи нет: сообщать об изменённых данных некому.
           notifyDataChanged: () => {
           },
-          channel: "web",
-          audience: "private",
+          channel,
+          audience,
           messageId: "",
           ...subject && { subject },
-          chat: { ...chatDataOfInput(chat) && { data: chatDataOfInput(chat) } }
+          chat: { ...chatDataOfInput(chat) && { data: chatDataOfInput(chat) } },
+          ...viewer && { viewer }
         };
         return helperToolsModel(model, {
           storage,
@@ -12829,6 +13371,8 @@ export {
   isCorrection,
   BURST_PART_TYPE,
   DEFAULT_BURST_QUIET_MS,
+  BURST_HOLD_MS,
+  BURST_SWEEP_LIMIT,
   isBurstMessage,
   RELEASED_ANSWER_ALIVE_AT,
   aliveAtByLocalClock,
@@ -12856,6 +13400,7 @@ export {
   ChatClosedError,
   isScreenPlaceInput,
   isTabId,
+  AgentViewerError,
   runHelper,
   MAX_SERVER_TURNS_IN_ROW,
   createChatEvents,
@@ -12928,4 +13473,4 @@ export {
   InvalidWidgetAnswerError,
   createChatService
 };
-//# sourceMappingURL=chunk-PWW3R3VL.js.map
+//# sourceMappingURL=chunk-BS2HDKZB.js.map