blun-king-cli 9.1.100 → 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/bin/user-message-offload-policy.cjs

@@ -0,0 +1,37 @@
+'use strict';
+
+const USER_MESSAGE_MAX_CHARS = 200_000;
+const USER_MESSAGE_PREVIEW_LINES = 5;
+const USER_MESSAGE_PREVIEW_LINE_CHARS = 1_000;
+const USER_MESSAGE_OFFLOAD_MARKER = '[User message offloaded]';
+
+function shouldOffloadUserMessage(textChars) {
+  return Number.isSafeInteger(textChars) && textChars > USER_MESSAGE_MAX_CHARS;
+}
+
+function createUserMessagePreview(text) {
+  const lines = String(text).split(/\r?\n/u);
+  const render = (line, index) => `${index}: ${line.slice(0, USER_MESSAGE_PREVIEW_LINE_CHARS)}`;
+  if (lines.length <= USER_MESSAGE_PREVIEW_LINES * 2) {
+    return lines.map((line, index) => render(line, index + 1)).join('\n');
+  }
+  const head = lines.slice(0, USER_MESSAGE_PREVIEW_LINES)
+    .map((line, index) => render(line, index + 1));
+  const tailStart = lines.length - USER_MESSAGE_PREVIEW_LINES;
+  const tail = lines.slice(tailStart)
+    .map((line, index) => render(line, tailStart + index + 1));
+  return [
+    ...head,
+    `... [${lines.length - USER_MESSAGE_PREVIEW_LINES * 2} lines omitted] ...`,
+    ...tail,
+  ].join('\n');
+}
+
+module.exports = {
+  USER_MESSAGE_MAX_CHARS,
+  USER_MESSAGE_OFFLOAD_MARKER,
+  USER_MESSAGE_PREVIEW_LINES,
+  USER_MESSAGE_PREVIEW_LINE_CHARS,
+  createUserMessagePreview,
+  shouldOffloadUserMessage,
+};

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
@@ -78758,6 +78758,7 @@ var init_context$2 = __esmMin((() => {
 			this.agent.replayBuilder.removeLastMessages(removedMessages);
 			this.agent.microCompaction.reset(this._history.length);
 			this.agent.toolResultBatchOffload.reset(this._history);
+			this.agent.userMessageOffload.reset(this._history);
 			this.agent.emitStatusUpdated();
 			return removedMessages.size;
 		}
@@ -78772,6 +78773,7 @@ var init_context$2 = __esmMin((() => {
 			this._lastAssistantAt = null;
 			this.agent.microCompaction.reset();
 			this.agent.toolResultBatchOffload.clear();
+			this.agent.userMessageOffload.clear();
 			this.agent.injection.onContextClear();
 			this.agent.emitStatusUpdated();
 		}
@@ -78811,6 +78813,7 @@ var init_context$2 = __esmMin((() => {
 			this.deferredMessages = [];
 			this.agent.microCompaction.reset(this._history.length);
 			this.agent.toolResultBatchOffload.reset(this._history);
+			this.agent.userMessageOffload.reset(this._history);
 			this.agent.emitStatusUpdated();
 			if (!this.agent.records.restoring && (stoppedAtBoundary || removedUserCount < count)) throw new BlunError(ErrorCodes.REQUEST_INVALID, formatUndoUnavailableMessage(count, removedUserCount, stoppedAtBoundary), { details: {
 				reason: "undo_limit",
@@ -78890,6 +78893,7 @@ var init_context$2 = __esmMin((() => {
 			this.tokenCountCoveredMessageCount = this._history.length;
 			this.agent.microCompaction.reset();
 			this.agent.toolResultBatchOffload.reset(this._history);
+			this.agent.userMessageOffload.reset(this._history);
 			this.agent.injection.onContextCompacted();
 			this.agent.emitStatusUpdated();
 			return result;
@@ -78912,7 +78916,7 @@ var init_context$2 = __esmMin((() => {
 		}
 		project(messages, options) {
 			const anomalies = [];
-			const result = project(this.agent.microCompaction.compact(this.agent.toolResultBatchOffload.compact(messages)), {
+			const result = project(this.agent.userMessageOffload.compact(this.agent.microCompaction.compact(this.agent.toolResultBatchOffload.compact(messages))), {
 				...options,
 				onAnomaly: (anomaly) => {
 					anomalies.push(anomaly);
@@ -234835,6 +234839,9 @@ function restoreAgentRecord(agent, input) {
 		case "tool_result_batch_offload.apply":
 			agent.toolResultBatchOffload.apply(input.replacements);
 			return;
+		case "user_message_offload.apply":
+			agent.userMessageOffload.apply(input.replacement);
+			return;
 		case "plan_mode.enter":
 			agent.planMode.restoreEnter(input);
 			return;
@@ -251762,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}.`);
 }
@@ -260237,6 +260251,121 @@ var ToolResultBatchOffload = class {
 	}
 };
 //#endregion
+//#region ../../packages/agent-core/src/agent/turn/user-message-offload.ts
+function persistableUserMessageText(message) {
+	if (message?.role !== "user" || message.origin?.kind !== "user") return;
+	const textParts = message.content.filter((part) => part.type === "text");
+	if (textParts.length === 0) return;
+	return textParts.map((part) => part.text).join("\n");
+}
+function userMessageOffloadHash(message, text) {
+	return createHash("sha256").update(JSON.stringify({
+		origin: message.origin,
+		text
+	})).digest("hex");
+}
+async function saveUserMessage(homedir, text) {
+	try {
+		const dir = join$4(homedir, "conversation-history");
+		await mkdir(dir, {
+			recursive: true,
+			mode: 448
+		});
+		const outputPath = join$4(dir, `user-message-${randomUUID()}.txt`);
+		await writeFile(outputPath, text, {
+			encoding: "utf8",
+			flag: "wx",
+			mode: 384
+		});
+		return outputPath;
+	} catch {
+		return;
+	}
+}
+function renderPersistedUserMessage(text, outputPath) {
+	return [
+		USER_MESSAGE_OFFLOAD_MARKER,
+		`Message text exceeded ${String(USER_MESSAGE_MAX_CHARS)} characters; the complete original remains in conversation history.`,
+		`message_size_chars: ${String(text.length)}`,
+		`message_size_bytes: ${String(Buffer.byteLength(text, "utf8"))}`,
+		`output_path: ${outputPath}`,
+		"next_step: Use Read with output_path to inspect the complete message in pages.",
+		"",
+		"[preview: head and tail]",
+		createUserMessagePreview(text)
+	].join("\n");
+}
+var USER_MESSAGE_MAX_CHARS, USER_MESSAGE_OFFLOAD_MARKER, shouldOffloadUserMessage, createUserMessagePreview;
+var init_user_message_offload = __esmMin((() => {
+	const policy = createRequire(import.meta.url)("./bin/user-message-offload-policy.cjs");
+	USER_MESSAGE_MAX_CHARS = policy.USER_MESSAGE_MAX_CHARS;
+	USER_MESSAGE_OFFLOAD_MARKER = policy.USER_MESSAGE_OFFLOAD_MARKER;
+	shouldOffloadUserMessage = policy.shouldOffloadUserMessage;
+	createUserMessagePreview = policy.createUserMessagePreview;
+}));
+var UserMessageOffload = class {
+	agent;
+	replacements = /* @__PURE__ */ new Map();
+	constructor(agent) {
+		this.agent = agent;
+	}
+	async detect() {
+		const message = this.agent.context.history.at(-1);
+		const text = persistableUserMessageText(message);
+		if (text === void 0 || !shouldOffloadUserMessage(text.length)) return 0;
+		const messageHash = userMessageOffloadHash(message, text);
+		if (this.replacements.has(messageHash) || this.agent.homedir === void 0) return 0;
+		const outputPath = await saveUserMessage(this.agent.homedir, text);
+		if (outputPath === void 0) return 0;
+		const replacementText = renderPersistedUserMessage(text, outputPath);
+		const content = [{
+			type: "text",
+			text: replacementText
+		}, ...message.content.filter((part) => part.type !== "text")];
+		this.apply({
+			messageHash,
+			content,
+			outputPath
+		});
+		this.agent.telemetry.track("user_message_offloaded", {
+			chars_before: text.length,
+			chars_after: replacementText.length,
+			chars_saved: text.length - replacementText.length,
+			media_part_count: content.length - 1
+		});
+		return 1;
+	}
+	apply(replacement) {
+		this.replacements.set(replacement.messageHash, replacement);
+		this.agent.records.logRecord({
+			type: "user_message_offload.apply",
+			replacement
+		});
+	}
+	compact(messages) {
+		if (this.replacements.size === 0) return messages;
+		return messages.map((message) => {
+			const text = persistableUserMessageText(message);
+			if (text === void 0) return message;
+			const replacement = this.replacements.get(userMessageOffloadHash(message, text));
+			return replacement === void 0 ? message : {
+				...message,
+				content: replacement.content
+			};
+		});
+	}
+	reset(history = this.agent.context?.history ?? []) {
+		const activeHashes = new Set(history.map((message) => {
+			const text = persistableUserMessageText(message);
+			return text === void 0 ? void 0 : userMessageOffloadHash(message, text);
+		}).filter((hash) => hash !== void 0));
+		for (const messageHash of this.replacements.keys()) if (!activeHashes.has(messageHash)) this.replacements.delete(messageHash);
+	}
+	clear() {
+		this.replacements.clear();
+	}
+};
+//#endregion
 //#region ../../packages/agent-core/src/agent/turn/index.ts
 function blunExtractText(content) {
 	if (typeof content === "string") return content;
@@ -260572,6 +260701,7 @@ var init_turn = __esmMin((() => {
 	init_canonical_args();
 	init_tool_dedup();
 	init_tool_result_budget();
+	init_user_message_offload();
 	({ CORE_TOOL_NAMES: BLUN_CORE_TOOL_NAMES, createDeferredToolLoader, toolSchemaBudgetTokens } = createRequire(import.meta.url)("./bin/turn-tool-performance-policy.cjs"));
 	BLUN_LEAN_TOOL_NAMES = new Set(BLUN_CORE_TOOL_NAMES);
 	BLUN_ATTACHMENT_MARKER_RE = /\b(?:attachment_file_id|telegram-anhang|telegram attachment)\b/i;
@@ -261206,6 +261336,7 @@ var init_turn = __esmMin((() => {
 							beforeStep: async ({ signal: stepSignal, stepNumber }) => {
 								await this.agent.records.flush();
 								this.agent.microCompaction.detect();
+								await this.agent.userMessageOffload.detect();
 								await this.agent.injection.inject();
 								stepSignal.throwIfAborted();
 								deduper.beginStep();
@@ -264014,6 +264145,7 @@ var init_agent = __esmMin((() => {
 			this.fullCompaction = new FullCompaction(this, options.compactionStrategy);
 			this.microCompaction = new MicroCompaction(this, options.microCompaction);
 			this.toolResultBatchOffload = new ToolResultBatchOffload(this);
+			this.userMessageOffload = new UserMessageOffload(this);
 			this.context = new ContextMemory(this);
 			this.config = new ConfigState(this);
 			this.turn = new TurnFlow(this);

package/package.json

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