blun-king-cli 9.1.75 → 9.1.76

package/LIESMICH.txt

@@ -43,6 +43,11 @@ einen aktiven Zug ab, ohne den geschriebenen Entwurf zu löschen. Das gilt auch
 bei Autovervollständigung, Geistervorschlägen, Bash-Eingabe und einer offenen
 Mehrzeileneingabe.
 
+Telegram-Nachrichten, die bei bereits aktivem Kernzug eintreffen, werden ohne
+konkurrierenden Start zurückgewiesen und bleiben an der Spitze der
+FIFO-Warteschlange. Für diesen normalen Wartestatus erscheint kein
+`turn.agent_busy`-Fehler.
+
 Zuverlässiger King-Start
 -----------------------
 Der Windows-Hilfsprozess für private Pfade übernimmt TEMP und TMP aus der
@@ -175,6 +180,11 @@ Marmor“ oder „Animiere das letzte Bild als ruhige Kamerafahrt von sechs Seku
 genügt. King wählt den passenden Medienweg und kann das asynchrone Ergebnis mit
 GetMedia abrufen.
 
+Ein angenommener Medienauftrag bleibt über Verdichtungen und schnelle
+Folgeturns hinweg gespeichert. Solange er offen ist, bleibt `GetMedia`
+verfügbar; King prüft den tatsächlichen Status, statt fälschlich zu behaupten,
+die Medienerzeugung sei nicht verfügbar.
+
 Angehängte Bilder werden weiterhin mit ReadMediaFile gelesen. Bild-, Video- und
 Spracherzeugung laufen asynchron, sodass die Konsole während der Verarbeitung
 nutzbar bleibt. GenerateVideo kann außerdem einen abgeschlossenen Bildauftrag

package/README.md

@@ -62,6 +62,10 @@ blun tools enable context7
 Telegram-Nachrichten werden in Eingangsreihenfolge verarbeitet. Trifft eine
 Nachricht im Leerlauf ein, startet die Warteschlange selbstständig; während
 eines Werkzeuglaufs wird sie am nächsten geschützten Übergabepunkt eingefügt.
+Telegram-Nachrichten, die bei bereits aktivem Kernzug eintreffen, werden ohne
+konkurrierenden Start zurückgewiesen und bleiben an der Spitze der
+FIFO-Warteschlange. Für diesen normalen Wartestatus erscheint kein
+`turn.agent_busy`-Fehler.
 `Strg+C` und `Esc` brechen einen aktiven Zug zuverlässig ab, ohne den bereits
 geschriebenen Entwurf zu löschen. Das gilt auch bei Autovervollständigung,
 Geistervorschlägen, Bash-Eingabe und einer noch offenen Mehrzeileneingabe.
@@ -203,6 +207,11 @@ Marmor“ oder „Animiere das letzte Bild als ruhige Kamerafahrt von sechs Seku
 genügt. King wählt den passenden Medienweg und kann das asynchrone Ergebnis mit
 `GetMedia` abrufen.
 
+Ein angenommener Medienauftrag bleibt über Verdichtungen und schnelle
+Folgeturns hinweg gespeichert. Solange er offen ist, bleibt `GetMedia`
+verfügbar; King prüft den tatsächlichen Status, statt fälschlich zu behaupten,
+die Medienerzeugung sei nicht verfügbar.
+
 Angehängte Bilder werden weiterhin mit `ReadMediaFile` gelesen. Bild-, Video-
 und Spracherzeugung laufen asynchron, sodass die Konsole während der Verarbeitung
 nutzbar bleibt. `GenerateVideo` kann außerdem einen abgeschlossenen Bildauftrag

package/bin/pending-media-policy.cjs

@@ -0,0 +1,43 @@
+'use strict';
+
+const TERMINAL_STATUSES = new Set([
+  'blocked',
+  'cancelled',
+  'canceled',
+  'complete',
+  'completed',
+  'expired',
+  'failed',
+  'succeeded',
+]);
+
+function validMediaId(value) {
+  return typeof value === 'string' && value.length > 0 && value.length <= 200
+    && /^[A-Za-z0-9_-]+$/.test(value);
+}
+
+function terminalStatus(value) {
+  return typeof value === 'string' && TERMINAL_STATUSES.has(value.trim().toLowerCase());
+}
+
+function createPendingMediaTracker() {
+  const pending = new Set();
+
+  return {
+    observeSubmission(job) {
+      if (!validMediaId(job?.id)) return;
+      if (terminalStatus(job?.status)) pending.delete(job.id);
+      else pending.add(job.id);
+    },
+    observeLookup(result) {
+      if (!validMediaId(result?.id)) return;
+      if (result.kind !== 'status' || terminalStatus(result.status)) pending.delete(result.id);
+      else pending.add(result.id);
+    },
+    ids() {
+      return [...pending];
+    },
+  };
+}
+
+module.exports = { createPendingMediaTracker };

package/blun.mjs

@@ -259942,9 +259942,14 @@ function blunToolsForOrigin(tools, origin) {
 	if (origin.kind !== "system_trigger" && origin.kind !== "injection") return tools;
 	return tools.filter((tool) => !BLUN_TELEGRAM_OUTBOUND_TOOL_RE.test(tool.name));
 }
-function blunFastConversationTools(tools, input) {
-	if (!BLUN_TELEGRAM_CHANNEL_RE.test(blunExtractText(input))) return [];
-	return tools.filter((tool) => BLUN_TELEGRAM_OUTBOUND_TOOL_RE.test(tool.name));
+function blunPendingMediaSystemPrompt(systemPrompt, pendingMediaJobIds) {
+	if (pendingMediaJobIds.length === 0) return systemPrompt;
+	return `${systemPrompt}\n\n## Pending BLUN media\n\nThe following media jobs were already accepted and are still pending: ${pendingMediaJobIds.join(", ")}. Call GetMedia exactly once for each listed id before replying. If a job is still processing, report that status truthfully and wait for a later turn; do not claim that media tools are unavailable.`;
+}
+function blunFastConversationTools(tools, input, pendingMediaJobIds = []) {
+	const telegramTurn = BLUN_TELEGRAM_CHANNEL_RE.test(blunExtractText(input));
+	const mediaPending = pendingMediaJobIds.length > 0;
+	return tools.filter((tool) => telegramTurn && BLUN_TELEGRAM_OUTBOUND_TOOL_RE.test(tool.name) || mediaPending && tool.name === "GetMedia");
 }
 /**
 * Keep frequently used native tools resident and expose every other tool by
@@ -260281,11 +260286,15 @@ var init_turn = __esmMin((() => {
 				input,
 				origin
 			});
-			const blocked = this.activeTurn !== null;
-			const buffered = !blocked && this.agent.fullCompaction.isCompacting;
+			if (this.activeTurn !== null) return {
+				accepted: false,
+				buffered: false,
+				turnId: null
+			};
+			const buffered = this.agent.fullCompaction.isCompacting;
 			const turnId = this.launch(input, origin);
 			return {
-				accepted: !blocked,
+				accepted: true,
 				buffered,
 				turnId
 			};
@@ -260773,7 +260782,9 @@ var init_turn = __esmMin((() => {
 			const turnHasAttachment = blunTurnHasAttachment(input);
 			const turnThinkingEffort = turnHasAttachment ? void 0 : selectThinkingEffortForTurn(blunExtractText(blunThinkingIntentInput(input)), origin.kind);
 			const fastConversation = turnThinkingEffort === "off" || turnThinkingEffort === "low";
-			const turnLLM = this.agent.llmForTurn(turnThinkingEffort, fastConversation ? this.agent.fastConversationSystemPrompt : void 0);
+			const pendingMediaJobIds = this.agent.toolServices?.media?.pendingMediaJobIds?.() ?? [];
+			const turnSystemPrompt = pendingMediaJobIds.length > 0 ? blunPendingMediaSystemPrompt(fastConversation ? this.agent.fastConversationSystemPrompt : this.agent.effectiveSystemPrompt, pendingMediaJobIds) : fastConversation ? this.agent.fastConversationSystemPrompt : void 0;
+			const turnLLM = this.agent.llmForTurn(turnThinkingEffort, turnSystemPrompt);
 			let previousStepToolOutcome = "initial";
 			let currentStepHadTool = false;
 			let currentStepHadFailure = false;
@@ -260785,7 +260796,7 @@ var init_turn = __esmMin((() => {
 				try {
 					const eligibleTools = blunToolsForOrigin(this.agent.injection.filterPersonalMemoryToolsForTurn(turnId, input, origin, this.agent.tools.loopTools), origin);
 					const toolSelection = fastConversation ? {
-						tools: [...blunFastConversationTools(eligibleTools, input)],
+						tools: [...blunFastConversationTools(eligibleTools, input, pendingMediaJobIds)],
 						deferredToolCount: 0
 					} : turnNeedsTools ? blunSelectTurnTools(eligibleTools, this.agent.config.modelCapabilities?.max_context_tokens, this.loadedToolNames) : {
 						tools: [],
@@ -260849,8 +260860,9 @@ var init_turn = __esmMin((() => {
 								if (steerEfforts.some((effort) => effort === void 0)) return;
 								const steerInput = pendingSteers.flatMap((steer) => [...steer.input]);
 								const steerThinkingEffort = "low";
-								const steerLLM = this.agent.llmForTurn(steerThinkingEffort, this.agent.fastConversationSystemPrompt);
-								const steerTools = [...blunFastConversationTools(eligibleTools, steerInput)];
+								const steerPendingMediaJobIds = this.agent.toolServices?.media?.pendingMediaJobIds?.() ?? [];
+								const steerLLM = this.agent.llmForTurn(steerThinkingEffort, blunPendingMediaSystemPrompt(this.agent.fastConversationSystemPrompt, steerPendingMediaJobIds));
+								const steerTools = [...blunFastConversationTools(eligibleTools, steerInput, steerPendingMediaJobIds)];
 								const steerHistory = () => blunFastConversationHistory(this.agent.context.history);
 								const buildSteerMessages = () => this.agent.context.project(steerHistory(), { dropOrphanResults: true });
 								const buildSteerMessagesStrict = () => this.agent.context.project(steerHistory(), {
@@ -311242,8 +311254,9 @@ async function assertSuccess(response, operation) {
 	} catch {}
 	throw new Error(`${operation} failed: HTTP ${String(response.status)}${detail ? `: ${detail}` : ""}`);
 }
-var BlunMediaService;
+var createPendingMediaTracker, BlunMediaService;
 var init_blun_media = __esmMin((() => {
+	({ createPendingMediaTracker } = createRequire(import.meta.url)("./bin/pending-media-policy.cjs"));
 	BlunMediaService = class {
 		tokenProvider;
 		apiKey;
@@ -311251,6 +311264,7 @@ var init_blun_media = __esmMin((() => {
 		defaultHeaders;
 		customHeaders;
 		fetchImpl;
+		pendingMedia = createPendingMediaTracker();
 		constructor(options) {
 			this.tokenProvider = options.tokenProvider;
 			this.apiKey = options.apiKey;
@@ -311303,28 +311317,28 @@ var init_blun_media = __esmMin((() => {
 		}
 		async getMedia(id, options) {
 			const response = await this.request(`/media/${encodeURIComponent(id)}`, { method: "GET" }, options);
-			if (response.status === 409) return parseBlockedStatus(response, id);
-			if (response.status === 410) return {
+			if (response.status === 409) return this.trackMediaLookup(parseBlockedStatus(response, id));
+			if (response.status === 410) return this.trackMediaLookup({
 				kind: "status",
 				id,
 				status: "expired"
-			};
+			});
 			await assertSuccess(response, "Media lookup");
 			const mimeType = response.headers.get("content-type")?.split(";", 1)[0]?.trim().toLowerCase() ?? "";
-			if (mimeType === "application/json" || mimeType.endsWith("+json")) return parseStatus(await response.json(), id);
-			if (mimeType === "text/plain") return {
+			if (mimeType === "application/json" || mimeType.endsWith("+json")) return this.trackMediaLookup(parseStatus(await response.json(), id));
+			if (mimeType === "text/plain") return this.trackMediaLookup({
 				kind: "text",
 				id,
 				mimeType,
 				text: await response.text()
-			};
+			});
 			if (!mimeType.startsWith("image/") && !mimeType.startsWith("audio/") && !mimeType.startsWith("video/")) throw new Error(`Media lookup returned unsupported content type ${mimeType || "(missing)"}`);
-			return {
+			return this.trackMediaLookup({
 				kind: "file",
 				id,
 				mimeType,
 				data: new Uint8Array(await response.arrayBuffer())
-			};
+			});
 		}
 		async submit(path, body, options) {
 			const response = await this.request(path, {
@@ -311333,7 +311347,16 @@ var init_blun_media = __esmMin((() => {
 			}, options);
 			if (response.status === 409) throw await blockedSubmissionError(response);
 			await assertSuccess(response, "Media request");
-			return parseJob(await response.json());
+			const job = parseJob(await response.json());
+			this.pendingMedia.observeSubmission(job);
+			return job;
+		}
+		trackMediaLookup(result) {
+			this.pendingMedia.observeLookup(result);
+			return result;
+		}
+		pendingMediaJobIds() {
+			return this.pendingMedia.ids();
 		}
 		async request(path, init, options) {
 			const firstToken = await this.resolveToken(false);

package/package.json

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