blun-king-cli 9.1.101 → 9.1.102

package/LIESMICH.txt

@@ -103,6 +103,8 @@ Das Telemetrieereignis `tool_result_batch_offloaded` meldet ausschließlich die
 
 Reguläre `Agent`-Teilaufgaben verwenden eine eigene `ContextMemory` und eine eigene `wire.jsonl` in einem getrennten Agentenverzeichnis. Der Hauptagent erhält nur die Ergebniszusammenfassung, sodass lange Teilaufgaben nicht den Hauptverlauf füllen. `TodoList` speichert Pläne weiterhin maschinenlesbar im Sitzungs-Wire; `blun handoff` übergibt sie zusammen mit prüfbaren Hashes zwischen CLI, Desktop und Web.
 
+Verliert ein delegierter Einzelagent die Provider-Verbindung, erhält er eine leere Provider-Antwort, trifft er auf einen Leerlaufabbruch des Streams oder meldet der Server einen wiederholbaren Status, setzt BLUN King denselben Agenten anhand seines dauerhaften Verlaufs fort. Die erste Fortsetzung wartet zwei Sekunden, die zweite fünf Sekunden; danach bleibt der ursprüngliche Fehler sichtbar. Die Fortsetzungsanweisung fordert den Agenten ausdrücklich auf, den erhaltenen Arbeitsstand zu prüfen und abgeschlossene Schritte nicht zu wiederholen. Authentifizierungs-, Guthaben-, Sicherheits-, Kontext- sowie beliebige Code- und Werkzeugfehler und manuelle Abbrüche bleiben endgültig. Dieser Schutz gilt für einen delegierten Einzelagenten; für Schwärme gelten weiterhin deren bestehende Zeitgrenzen- und Überlastungsregeln.
+
 Rein lesende Sitzungsdiagnose
 --------------------------------
 

package/bin/subagent-timeout-policy.cjs

@@ -3,6 +3,26 @@
 const DEFAULT_SUBAGENT_TIMEOUT_MS = 4 * 60 * 60 * 1000;
 const MAX_SUBAGENT_TIMEOUT_MINUTES = 7 * 24 * 60;
 const SUBAGENT_TIMEOUT_ENV = "BLUN_SUBAGENT_TIMEOUT_MINUTES";
+const MAX_TRANSIENT_SUBAGENT_CONTINUATIONS = 2;
+const DEFAULT_TRANSIENT_RETRY_DELAYS_MS = Object.freeze([2000, 5000]);
+const TERMINAL_ERROR_CODES = new Set([
+  "auth.login_required",
+  "context.overflow",
+  "provider.auth_error",
+  "provider.quota_exhausted",
+]);
+const RETRYABLE_ERROR_CODES = new Set([
+  "compaction.stalled",
+  "provider.connection_error",
+  "provider.rate_limit",
+]);
+const RETRYABLE_ERROR_NAMES = new Set([
+  "APIConnectionError",
+  "APIEmptyResponseError",
+  "APITimeoutError",
+  "CompactionStallError",
+]);
+const RETRYABLE_MESSAGE_RE = /(?:\[provider\.(?:connection_error|rate_limit)\]|\[compaction\.stalled\]|no provider data arrived|stream was aborted to prevent an indefinite hang|\b(?:econnreset|econnrefused|etimedout)\b|fetch failed|socket hang up|connection (?:closed|reset|terminated|timed out)|network error)/iu;
 
 function resolveSubagentTimeoutMs({ perRunMinutes, env = process.env } = {}) {
   const raw = perRunMinutes ?? env[SUBAGENT_TIMEOUT_ENV];
@@ -24,14 +44,63 @@ function abortError(reason) {
   return new Error(reason === undefined ? "Subagent interrupted." : String(reason));
 }
 
+function errorField(error, field) {
+  return typeof error === "object" && error !== null ? error[field] : undefined;
+}
+
+function isRetryableSubagentFailure(error) {
+  const code = errorField(error, "code");
+  const statusCode = errorField(error, "statusCode") ?? errorField(error, "status");
+  const name = errorField(error, "name");
+  const message = error instanceof Error ? error.message : String(error);
+
+  if (typeof code === "string" && TERMINAL_ERROR_CODES.has(code)) return false;
+  if (statusCode === 401 || statusCode === 402 || statusCode === 403
+    || statusCode === 413 || statusCode === 422) return false;
+  if (/safety policy|filtered|payment|required quota|context (?:window )?(?:overflow|too long)/iu.test(message)) {
+    return false;
+  }
+  if (typeof code === "string" && RETRYABLE_ERROR_CODES.has(code)) return true;
+  if (typeof name === "string" && RETRYABLE_ERROR_NAMES.has(name)) return true;
+  if (statusCode === 408 || statusCode === 429
+    || statusCode === 500 || statusCode === 502 || statusCode === 503 || statusCode === 504) {
+    return true;
+  }
+  if (errorField(error, "retryable") === true
+    && typeof code === "string"
+    && (code.startsWith("provider.") || code.startsWith("compaction."))) {
+    return true;
+  }
+  return RETRYABLE_MESSAGE_RE.test(message);
+}
+
+function waitForRetryDelay(delayMs, signal) {
+  if (delayMs <= 0) return Promise.resolve();
+  if (signal.aborted) return Promise.reject(abortError(signal.reason));
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, delayMs);
+    const onAbort = () => {
+      clearTimeout(timeout);
+      signal.removeEventListener("abort", onAbort);
+      reject(abortError(signal.reason));
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
 async function runAgentWithTimeoutContinuation({
   handle,
   timeoutMs,
   signal,
   abortCurrent,
   retrySameAgent,
+  retryDelaysMs = DEFAULT_TRANSIENT_RETRY_DELAYS_MS,
 }) {
   let currentHandle = handle;
+  let transientContinuations = 0;
 
   while (true) {
     let timeout;
@@ -58,7 +127,24 @@ async function runAgentWithTimeoutContinuation({
     removeAbortListener();
 
     if (result.kind === "completed") return { handle: currentHandle, outcome: result.outcome };
-    if (result.kind === "failed") throw result.error;
+    if (result.kind === "failed") {
+      if (signal.aborted) throw abortError(signal.reason);
+      if (!isRetryableSubagentFailure(result.error)
+        || transientContinuations >= MAX_TRANSIENT_SUBAGENT_CONTINUATIONS) {
+        throw result.error;
+      }
+      const attempt = transientContinuations + 1;
+      const delayMs = retryDelaysMs[transientContinuations] ?? retryDelaysMs.at(-1) ?? 0;
+      transientContinuations = attempt;
+      await waitForRetryDelay(delayMs, signal);
+      currentHandle = await retrySameAgent(currentHandle.agentId, {
+        kind: "transient_provider",
+        attempt,
+        maxAttempts: MAX_TRANSIENT_SUBAGENT_CONTINUATIONS,
+        error: result.error,
+      });
+      continue;
+    }
     if (result.kind === "interrupted") {
       abortCurrent(result.reason);
       await Promise.resolve(currentHandle.completion).catch(() => {});
@@ -68,12 +154,14 @@ async function runAgentWithTimeoutContinuation({
     const reason = new Error("Subagent continuation interval elapsed.");
     abortCurrent(reason);
     await Promise.resolve(currentHandle.completion).catch(() => {});
-    currentHandle = await retrySameAgent(currentHandle.agentId);
+    currentHandle = await retrySameAgent(currentHandle.agentId, { kind: "wall_clock" });
   }
 }
 
 module.exports = {
   DEFAULT_SUBAGENT_TIMEOUT_MS,
+  MAX_TRANSIENT_SUBAGENT_CONTINUATIONS,
+  isRetryableSubagentFailure,
   resolveSubagentTimeoutMs,
   runAgentWithTimeoutContinuation,
 };

package/blun.mjs

@@ -29058,11 +29058,11 @@ var init_agent_task = __esmMin((() => {
 					abortCurrent: (reason) => {
 						this.abortController.abort(reason);
 					},
-					retrySameAgent: async (agentId) => {
+					retrySameAgent: async (agentId, continuation) => {
 						this.abortController = new AbortController();
 						this.handle = await this.subagentHost.retry(agentId, {
 							parentToolCallId: this.parentToolCallId,
-							prompt: "Continue from the preserved context after the wall-clock interval.",
+							prompt: continuation.kind === "transient_provider" ? "Continue from the preserved context after a transient provider interruption. Do not repeat completed work; inspect the preserved wire and continue from the last durable boundary." : "Continue from the preserved context after the wall-clock interval.",
 							description: this.description,
 							runInBackground: this.runInBackground,
 							signal: this.abortController.signal
@@ -251769,7 +251769,14 @@ async function runChildTurnToCompletion(child, signal) {
 	if (turnEnded.reason !== "completed") {
 		if (turnEnded.reason === "filtered") throw new Error("Subagent turn blocked by provider safety policy");
 		if (turnEnded.error?.code === ErrorCodes.PROVIDER_RATE_LIMIT) throw providerRateLimitErrorFromPayload(turnEnded.error);
-		throw new Error(turnEnded.error === void 0 ? `Subagent turn ${turnEnded.reason}` : `[${turnEnded.error.code}] ${turnEnded.error.message}`);
+		if (turnEnded.error === void 0) throw new Error(`Subagent turn ${turnEnded.reason}`);
+		const error = new Error(`[${turnEnded.error.code}] ${turnEnded.error.message}`);
+		error.name = turnEnded.error.name ?? "Error";
+		error.code = turnEnded.error.code;
+		error.retryable = turnEnded.error.retryable;
+		const statusCode = turnEnded.error.details?.["statusCode"];
+		if (typeof statusCode === "number") error.statusCode = statusCode;
+		throw error;
 	}
 	if (completion.stopReason === "max_tokens") throw new Error(`${SUBAGENT_MAX_TOKENS_ERROR}.`);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blun-king-cli",
-  "version": "9.1.101",
+  "version": "9.1.102",
   "description": "BLUN CLI - your own AI agent with a Telegram channel. Get it done. With BLUN.",
   "license": "MIT",
   "bin": {