@ykurilov/agent-chat-core 0.57.0 → 0.58.0

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # @ykurilov/agent-chat-core
 
+## 0.58.0
+
+### Minor Changes
+
+- 332d90e: Новый параметр службы `abandonedBursts: { serviceFor }`: при нескольких службах на одном хранилище обход брошенных пачек
+  (`answerAfterRestart`) отдаёт пачку службе, которую назвало приложение, — её инструкция и модель отвечают. `serviceFor`
+  может создать службу по требованию; вернула `null` или упала — пачка ждёт следующего обхода, чужая служба её не берёт. Тот же параметр — у `createChatServer`.
+- 2ed600d: Пустой счёт (402) или непринятый ключ (401, 403 со словами о ключе или деньгах) у провайдера — без повторов сразу следующий из запасных (`providerFallback`), в любом шаге хода и у помощников. Отказавший провайдер 5 минут на паузе: новые ходы службы сразу идут к запасному, после паузы его пробует один ход. Прочие 403 (регион, доступ к модели) — запасной без паузы, 403 модерации — ошибка без перехода. 429 со словами о квоте — лимит запросов, а не пустой счёт (кроме `insufficient_quota`). Основной отказал в этом ходе, а запасные не ответили — человеку его причина, а если запасной лишь перегружен — перегрузка. Строки журнала `[запасной провайдер] … причина=insufficient_funds|invalid_key` и громкая `[ВНИМАНИЕ провайдер]` не чаще раза в 15 минут на провайдер.
+- 760962e: Хранилища пакетов на PostgreSQL можно открывать одновременно на совсем пустой базе. Раньше пакеты разом создавали
+  схему `agent_chat`, проигравший падал на `CREATE SCHEMA IF NOT EXISTS`, и его хранилище не работало до перезапуска.
+  Теперь схема создаётся под общей блокировкой всех пакетов, она держится только на создании схемы. Миграции идут под
+  своей блокировкой пакета: разные пакеты друг друга не ждут, взаимной блокировки нет. Столкновение «такое уже есть»
+  повторяется само. Новое в core: `migratePostgresSchema({ connect, lockKey, migrate })` — для своих пакетов на той же
+  схеме.
+  
+  ### Как обновить приложение
+  
+  Ничего делать не нужно.
+
 ## 0.57.0
 
 ### Minor Changes

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

@@ -2484,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",
@@ -2534,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);
@@ -2573,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);
@@ -2747,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";
@@ -2756,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";
@@ -2765,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";
@@ -2790,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) {
@@ -4348,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 }) };
@@ -4358,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)) {
@@ -5995,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);
@@ -6092,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;
@@ -6133,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;
@@ -6210,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 })
@@ -6823,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 }
@@ -7053,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],
@@ -7089,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);
@@ -11035,6 +11141,7 @@ var InvalidWidgetAnswerError = class extends Error {
   }
 };
 var FAR_FUTURE_ISO = "9999-12-31T23:59:59.999Z";
+var abandonedBurstReceivers = /* @__PURE__ */ new WeakMap();
 var TurnEndedBeforeSubscribeError = class extends Error {
   constructor(chatId) {
     super(`\u0425\u043E\u0434 \u0432 \u0447\u0430\u0442\u0435 ${chatId} \u0437\u0430\u043A\u043E\u043D\u0447\u0438\u043B\u0441\u044F \u0434\u043E \u043F\u043E\u0434\u043F\u0438\u0441\u043A\u0438`);
@@ -11232,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();
@@ -11907,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) },
@@ -12229,10 +12338,10 @@ function createChatService(input) {
       ...page && { page }
     });
   }
-  function renewingBurstHold(chatId, messageId, dueAt) {
+  function renewingBurstHold(chatId, messageId, dueAt, holder) {
     const timer = setInterval(() => {
       const heldUntil = new Date(Math.max(now().getTime(), dueAt) + BURST_HOLD_MS).toISOString();
-      storage.renewPendingBurst({ chatId, messageId, holder: copyId, heldUntil }).then(
+      storage.renewPendingBurst({ chatId, messageId, holder, heldUntil }).then(
         (held) => {
           if (!held) clearInterval(timer);
         },
@@ -12246,7 +12355,7 @@ function createChatService(input) {
   function answeringRecordedBurst(ownerId, chatId, questionId, page, burst) {
     const unattended = burst.kept && burst.unattended === true;
     if (!burst.kept || !keepsPendingBursts) return burstWaits.holding(chatId, () => answeringBurst(ownerId, chatId, questionId, page, unattended));
-    const stopRenewing = renewingBurstHold(chatId, questionId, burst.dueAt);
+    const stopRenewing = renewingBurstHold(chatId, questionId, burst.dueAt, burst.holder ?? copyId);
     const answering = burstWaits.holding(chatId, () => answeringBurst(ownerId, chatId, questionId, page, unattended)).finally(stopRenewing);
     void answering.then(
       () => true,
@@ -12272,6 +12381,37 @@ function createChatService(input) {
     const why = error instanceof TurnRefusedError ? `\u043E\u0442\u043A\u0430\u0437 \u043F\u0440\u0438\u043B\u043E\u0436\u0435\u043D\u0438\u044F ${error.code}: ${error.message}` : error instanceof Error ? error.message : String(error);
     logError(`\u0425\u043E\u0434 \u043D\u0430 \u0431\u0440\u043E\u0448\u0435\u043D\u043D\u0443\u044E \u043F\u0430\u0447\u043A\u0443 \u0447\u0430\u0442\u0430 ${chatId} \u043D\u0435 \u043D\u0430\u0447\u0430\u043B\u0441\u044F: ${why}`);
   }
+  async function receivingAbandonedBurst(burst) {
+    if (burstWaits.has(burst.chatId)) return;
+    await answeringRecordedBurst(burst.ownerId, burst.chatId, burst.messageId, burst.page, { kept: true, dueAt: Date.parse(burst.dueAt), unattended: true, holder: burst.holder }).then(
+      () => {
+      },
+      (error) => reportingAbandonedBurst(burst.chatId, error)
+    );
+  }
+  async function routingAbandonedBurst(burst) {
+    const serviceFor = options2.abandonedBursts?.serviceFor;
+    if (!serviceFor) return receivingAbandonedBurst(burst);
+    let target;
+    try {
+      const chat = await storage.getChat(burst.chatId);
+      if (!chat) return receivingAbandonedBurst(burst);
+      target = await serviceFor({ ownerId: burst.ownerId, chatId: burst.chatId, chat });
+    } catch (error) {
+      logError(`\u0421\u043B\u0443\u0436\u0431\u0430 \u0434\u043B\u044F \u0431\u0440\u043E\u0448\u0435\u043D\u043D\u043E\u0439 \u043F\u0430\u0447\u043A\u0438 \u0447\u0430\u0442\u0430 ${burst.chatId} \u043D\u0435 \u043D\u0430\u0448\u043B\u0430\u0441\u044C (serviceFor): ${error instanceof Error ? error.message : String(error)} \u2014 \u043F\u0430\u0447\u043A\u0430 \u0436\u0434\u0451\u0442 \u0441\u043B\u0435\u0434\u0443\u044E\u0449\u0435\u0433\u043E \u043E\u0431\u0445\u043E\u0434\u0430`);
+      return;
+    }
+    if (!target) {
+      logError(`\u0414\u043B\u044F \u0431\u0440\u043E\u0448\u0435\u043D\u043D\u043E\u0439 \u043F\u0430\u0447\u043A\u0438 \u0447\u0430\u0442\u0430 ${burst.chatId} \u043D\u0435\u0442 \u0441\u043B\u0443\u0436\u0431\u044B (serviceFor \u2192 ${String(target)}): \u043F\u0430\u0447\u043A\u0430 \u0436\u0434\u0451\u0442 \u0441\u043B\u0435\u0434\u0443\u044E\u0449\u0435\u0433\u043E \u043E\u0431\u0445\u043E\u0434\u0430`);
+      return;
+    }
+    const receive = abandonedBurstReceivers.get(target);
+    if (!receive) {
+      logError(`serviceFor \u0434\u043B\u044F \u0431\u0440\u043E\u0448\u0435\u043D\u043D\u043E\u0439 \u043F\u0430\u0447\u043A\u0438 \u0447\u0430\u0442\u0430 ${burst.chatId} \u0432\u0435\u0440\u043D\u0443\u043B \u043D\u0435 \u0441\u043B\u0443\u0436\u0431\u0443 \u0447\u0430\u0442\u0430 SDK: \u043F\u0430\u0447\u043A\u0430 \u0436\u0434\u0451\u0442 \u0441\u043B\u0435\u0434\u0443\u044E\u0449\u0435\u0433\u043E \u043E\u0431\u0445\u043E\u0434\u0430`);
+      return;
+    }
+    await receive(burst);
+  }
   function sweepingBursts(take) {
     if (!keepsPendingBursts || closing) return Promise.resolve();
     const sweep = (async () => {
@@ -12286,9 +12426,8 @@ function createChatService(input) {
         const taken = await storage.takeAbandonedBursts({ ...take, holder: copyId, heldUntil, limit: free });
         if (taken.length === 0) return;
         for (const burst of taken) {
-          if (burstWaits.has(burst.chatId)) continue;
           burstDecisions++;
-          answeringRecordedBurst(burst.ownerId, burst.chatId, burst.messageId, burst.page, { kept: true, dueAt: Date.parse(burst.dueAt), unattended: true }).catch((error) => reportingAbandonedBurst(burst.chatId, error)).finally(releasingBurstDecision);
+          void routingAbandonedBurst(burst).finally(releasingBurstDecision);
         }
       }
     })().catch((error) => logError(`\u041E\u0431\u0445\u043E\u0434 \u0436\u0434\u0443\u0449\u0438\u0445 \u043F\u0430\u0447\u0435\u043A \u043D\u0435 \u0443\u0434\u0430\u043B\u0441\u044F: ${error instanceof Error ? error.message : String(error)}`)).finally(() => burstSweeps.delete(sweep));
@@ -13203,6 +13342,7 @@ function createChatService(input) {
           modelSilence,
           logError,
           ...providerFallback !== void 0 && { providerFallback },
+          providerOutages,
           ...options2.turnObserver && { turnObserver: options2.turnObserver },
           ...options2.limits && { assertWithinLimit: () => assertWithinSpendingLimit(ownerId, chatId) }
         });
@@ -13212,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);
@@ -13473,4 +13614,4 @@ export {
   InvalidWidgetAnswerError,
   createChatService
 };
-//# sourceMappingURL=chunk-BS2HDKZB.js.map
+//# sourceMappingURL=chunk-KAG3QTZC.js.map