blun-king-cli 9.1.102 → 9.1.103

package/LIESMICH.txt

@@ -103,7 +103,7 @@ 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.
+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

@@ -74,6 +74,18 @@ function isRetryableSubagentFailure(error) {
   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));
@@ -134,7 +146,8 @@ async function runAgentWithTimeoutContinuation({
         throw result.error;
       }
       const attempt = transientContinuations + 1;
-      const delayMs = retryDelaysMs[transientContinuations] ?? retryDelaysMs.at(-1) ?? 0;
+      const delayMs = retryDelaysMs[transientContinuations]
+        ?? transientSubagentRetryDelayMs(attempt);
       transientContinuations = attempt;
       await waitForRetryDelay(delayMs, signal);
       currentHandle = await retrySameAgent(currentHandle.agentId, {
@@ -164,4 +177,6 @@ module.exports = {
   isRetryableSubagentFailure,
   resolveSubagentTimeoutMs,
   runAgentWithTimeoutContinuation,
+  shouldStopTransientSubagentContinuation,
+  transientSubagentRetryDelayMs,
 };

package/blun.mjs

@@ -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();
 		}

package/package.json

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