blun-king-cli 9.1.101 → 9.1.103

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 oder ein Mitglied eines Agentenschwarms die Provider-Verbindung, erhält es eine leere Provider-Antwort, bricht sein Stream wegen Leerlaufs ab oder meldet der Server HTTP 408/500/502/503/504, setzt BLUN King denselben Agenten anhand seines dauerhaften Verlaufs fort. Bei Einzelagenten sowie bei Schwarm-Unterbrechungen außerhalb von HTTP 429 wartet die erste Fortsetzung zwei Sekunden und die zweite fünf Sekunden; danach bleibt der ursprüngliche Fehler sichtbar. HTTP 429 behält im Schwarm seine getrennte, längere Überlastungsregel. Authentifizierungs-, Zahlungs- oder Kontingent-, Richtlinien-, Kontext-, Werkzeug- und Codefehler sowie manuelle Abbrüche lösen keine automatische Fortsetzung aus. Jeder Fortsetzungsversuch verwendet die bestehende Agenten-ID, damit bereits abgeschlossene Arbeit nicht wiederholt wird.
+
 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,75 @@ 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 transientSubagentRetryDelayMs(retryCount) {
+  if (!Number.isInteger(retryCount) || retryCount < 1) {
+    throw new Error("retryCount must be a positive integer.");
+  }
+  return DEFAULT_TRANSIENT_RETRY_DELAYS_MS[retryCount - 1]
+    ?? DEFAULT_TRANSIENT_RETRY_DELAYS_MS.at(-1);
+}
+
+function shouldStopTransientSubagentContinuation(retryCount) {
+  return retryCount >= MAX_TRANSIENT_SUBAGENT_CONTINUATIONS;
+}
+
+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 +139,25 @@ 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]
+        ?? transientSubagentRetryDelayMs(attempt);
+      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 +167,16 @@ 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,
+  shouldStopTransientSubagentContinuation,
+  transientSubagentRetryDelayMs,
 };

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
@@ -251353,18 +251353,20 @@ function resolveSwarmMaxConcurrency(env = process.env) {
 	if (!Number.isInteger(value) || value <= 0) throw new Error(`${AGENT_SWARM_MAX_CONCURRENCY_ENV} must be a positive integer, got ${JSON.stringify(raw)}.`);
 	return value;
 }
-var import_retry, INITIAL_LAUNCH_LIMIT, INITIAL_LAUNCH_INTERVAL_MS, RATE_LIMIT_RETRY_BASE_MS, RATE_LIMIT_RETRY_FACTOR, RATE_LIMIT_CAPACITY_SHRINK_INTERVAL_MS, RATE_LIMIT_CAPACITY_RECOVERY_INTERVAL_MS, RATE_LIMIT_SUSPENDED_REASON, AGENT_SWARM_MAX_CONCURRENCY_ENV, MAX_AUTOMATIC_RATE_LIMIT_RESUMES, rateLimitRetryDelayMs, shouldCompactBeforeRateLimitResume, shouldStopAutomaticRateLimitResume, SubagentBatch;
+var import_retry, INITIAL_LAUNCH_LIMIT, INITIAL_LAUNCH_INTERVAL_MS, RATE_LIMIT_RETRY_BASE_MS, RATE_LIMIT_RETRY_FACTOR, RATE_LIMIT_CAPACITY_SHRINK_INTERVAL_MS, RATE_LIMIT_CAPACITY_RECOVERY_INTERVAL_MS, RATE_LIMIT_SUSPENDED_REASON, TRANSIENT_PROVIDER_SUSPENDED_REASON, AGENT_SWARM_MAX_CONCURRENCY_ENV, MAX_AUTOMATIC_RATE_LIMIT_RESUMES, MAX_TRANSIENT_SUBAGENT_CONTINUATIONS, isRetryableSubagentFailure, rateLimitRetryDelayMs, shouldCompactBeforeRateLimitResume, shouldStopAutomaticRateLimitResume, shouldStopTransientSubagentContinuation, transientSubagentRetryDelayMs, SubagentBatch;
 var init_subagent_batch = __esmMin((() => {
 	init_src$4();
 	import_retry = /* @__PURE__ */ __toESM(require_retry$1(), 1);
 	init_abort();
 	({ MAX_AUTOMATIC_RATE_LIMIT_RESUMES, RATE_LIMIT_RETRY_BASE_MS, rateLimitRetryDelayMs, shouldCompactBeforeRateLimitResume, shouldStopAutomaticRateLimitResume } = createRequire(import.meta.url)("./bin/rate-limit-recovery-policy.cjs"));
+	({ MAX_TRANSIENT_SUBAGENT_CONTINUATIONS, isRetryableSubagentFailure, shouldStopTransientSubagentContinuation, transientSubagentRetryDelayMs } = createRequire(import.meta.url)("./bin/subagent-timeout-policy.cjs"));
 	INITIAL_LAUNCH_LIMIT = 5;
 	INITIAL_LAUNCH_INTERVAL_MS = 700;
 	RATE_LIMIT_RETRY_FACTOR = 2;
 	RATE_LIMIT_CAPACITY_SHRINK_INTERVAL_MS = 2e3;
 	RATE_LIMIT_CAPACITY_RECOVERY_INTERVAL_MS = 180 * 1e3;
 	RATE_LIMIT_SUSPENDED_REASON = "Provider rate limit; subagent requeued for retry.";
+	TRANSIENT_PROVIDER_SUSPENDED_REASON = "Transient provider interruption; subagent requeued for continuation.";
 	AGENT_SWARM_MAX_CONCURRENCY_ENV = "BLUN_AGENT_SWARM_MAX_CONCURRENCY";
 	SubagentBatch = class {
 		launcher;
@@ -251379,6 +251381,7 @@ var init_subagent_batch = __esmMin((() => {
 		normalLaunchCount = 0;
 		normalLaunchTimer;
 		rateLimitLaunchTimer;
+		transientRetryTimers = /* @__PURE__ */ new Set();
 		resolve;
 		reject;
 		finished = false;
@@ -251398,6 +251401,7 @@ var init_subagent_batch = __esmMin((() => {
 				index,
 				task,
 				retryCount: 0,
+				transientRetryCount: 0,
 				retryReadyAt: 0,
 				started: false
 			}));
@@ -251540,6 +251544,11 @@ var init_subagent_batch = __esmMin((() => {
 					agentId: handle.agentId,
 					error: this.attemptErrorMessage(attempt, error, "failed")
 				};
+				if (isRetryableSubagentFailure(error)) return {
+					type: "transient_provider",
+					agentId: handle.agentId,
+					error: this.attemptErrorMessage(attempt, error, "failed")
+				};
 				return this.failedAttemptOutcome(attempt, error);
 			}
 		}
@@ -251571,6 +251580,14 @@ var init_subagent_batch = __esmMin((() => {
 				this.requeueTimedOut(attempt, outcome.agentId);
 			}
 			else if ("status" in outcome) this.results[attempt.state.index] = outcome;
+			else if (outcome.type === "transient_provider" && shouldStopTransientSubagentContinuation(attempt.state.transientRetryCount)) this.results[attempt.state.index] = {
+				task: attempt.state.task,
+				agentId: outcome.agentId,
+				status: "failed",
+				state: "started",
+				error: `${outcome.error} Automatic continuation stopped after ${String(MAX_TRANSIENT_SUBAGENT_CONTINUATIONS)} attempts; agent ${outcome.agentId} remains resumable.`
+			};
+			else if (outcome.type === "transient_provider") this.requeueTransientProvider(attempt, outcome.agentId);
 			else if (shouldStopAutomaticRateLimitResume(attempt.state.retryCount)) this.results[attempt.state.index] = {
 				task: attempt.state.task,
 				agentId: outcome.agentId,
@@ -251604,6 +251621,26 @@ var init_subagent_batch = __esmMin((() => {
 			attempt.cleanup();
 			return true;
 		}
+		requeueTransientProvider(attempt, agentId) {
+			const state = attempt.state;
+			state.agentId = agentId;
+			state.retryAgentId = agentId;
+			state.transientRetryCount += 1;
+			this.launcher.suspended?.({
+				task: state.task,
+				agentId,
+				reason: TRANSIENT_PROVIDER_SUSPENDED_REASON
+			});
+			const retryDelay = transientSubagentRetryDelayMs(state.transientRetryCount);
+			const timer = setTimeout(() => {
+				this.transientRetryTimers.delete(timer);
+				if (this.finished || this.controller.signal.aborted) return;
+				state.retryReadyAt = 0;
+				this.pending.unshift(state);
+				this.schedule();
+			}, retryDelay);
+			this.transientRetryTimers.add(timer);
+		}
 		requeueRateLimited(attempt, agentId) {
 			const state = attempt.state;
 			state.agentId = agentId;
@@ -251714,6 +251751,8 @@ var init_subagent_batch = __esmMin((() => {
 			this.batchSignal?.removeEventListener("abort", this.batchAbortListener);
 			this.clearNormalTimer();
 			this.clearRateLimitTimer();
+			for (const timer of this.transientRetryTimers) clearTimeout(timer);
+			this.transientRetryTimers.clear();
 			for (const attempt of this.active.values()) attempt.cleanup();
 			this.active.clear();
 		}
@@ -251769,7 +251808,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.103",
   "description": "BLUN CLI - your own AI agent with a Telegram channel. Get it done. With BLUN.",
   "license": "MIT",
   "bin": {