blun-king-cli 9.1.233 → 9.1.235

package/bin/assistant-message-offload-policy.cjs

@@ -8,6 +8,7 @@ const ASSISTANT_MESSAGE_OFFLOAD_MARKER = '[Assistant message offloaded]';
 const ASSISTANT_TOOL_NARRATION_MIN_CHARS = 120;
 const ASSISTANT_TOOL_NARRATION_MARKER = '[Earlier completed tool-step narration compacted]';
 const ASSISTANT_POST_TELEGRAM_REPLY_MARKER = '[Earlier post-reply status compacted]';
+const ASSISTANT_COMPLETED_SUBAGENT_PROMPT_MARKER = '[Earlier completed subagent task omitted; use its result below]';
 const SYNTHETIC_TOOL_ARGUMENT_MARKER = JSON.stringify({
   _blun_compacted: '[Old tool call arguments cleared]',
 });
@@ -123,6 +124,78 @@ function compactHistoricalPostTelegramReplyNarration(messages) {
   return changed ? projected : messages;
 }
 
+function completedSubagentResultIds(messages) {
+  return new Set(messages.filter((message) => {
+    if (
+      message?.role !== 'tool'
+      || typeof message.toolCallId !== 'string'
+      || message.isError === true
+      || !Array.isArray(message.content)
+      || !message.content.every((part) => part?.type === 'text' && typeof part.text === 'string')
+    ) return false;
+    const text = message.content.map((part) => part.text).join('\n');
+    return /(?:^|\n)status:\s*completed(?:\s|$)/iu.test(text);
+  }).map((message) => message.toolCallId));
+}
+
+function compactCompletedSubagentCall(call, completedIds) {
+  if (
+    call?.name !== 'Agent'
+    || !completedIds.has(call.id)
+    || (typeof call.arguments !== 'string'
+      && (call.arguments === null || typeof call.arguments !== 'object' || Array.isArray(call.arguments)))
+  ) return call;
+
+  let args = call.arguments;
+  if (typeof args === 'string') {
+    try {
+      args = JSON.parse(args);
+    } catch {
+      return call;
+    }
+  }
+  if (args === null || typeof args !== 'object' || Array.isArray(args)) return call;
+  if (
+    typeof args.prompt !== 'string'
+    || args.prompt.length <= ASSISTANT_COMPLETED_SUBAGENT_PROMPT_MARKER.length
+    || args.prompt === ASSISTANT_COMPLETED_SUBAGENT_PROMPT_MARKER
+  ) return call;
+
+  const compactedArgs = {
+    ...args,
+    prompt: ASSISTANT_COMPLETED_SUBAGENT_PROMPT_MARKER,
+  };
+  return {
+    ...call,
+    arguments: typeof call.arguments === 'string'
+      ? JSON.stringify(compactedArgs)
+      : compactedArgs,
+  };
+}
+
+function compactHistoricalCompletedSubagentPrompts(messages) {
+  if (!Array.isArray(messages) || messages.length === 0) return messages;
+
+  const completedIds = completedSubagentResultIds(messages);
+  if (completedIds.size === 0) return messages;
+  const recentStart = Math.max(0, messages.length - ASSISTANT_MESSAGE_KEEP_RECENT_MESSAGES);
+  let changed = false;
+  const projected = messages.map((message, historyIndex) => {
+    if (
+      historyIndex >= recentStart
+      || message?.role !== 'assistant'
+      || !Array.isArray(message.toolCalls)
+      || message.toolCalls.length === 0
+    ) return message;
+    const toolCalls = message.toolCalls.map((call) => compactCompletedSubagentCall(call, completedIds));
+    if (toolCalls.every((call, index) => call === message.toolCalls[index])) return message;
+    changed = true;
+    return { ...message, toolCalls };
+  });
+
+  return changed ? projected : messages;
+}
+
 function removeSyntheticToolArgumentFailures(messages) {
   if (!Array.isArray(messages) || messages.length === 0) return messages;
 
@@ -179,6 +252,8 @@ module.exports = {
   ASSISTANT_TOOL_NARRATION_MARKER,
   ASSISTANT_TOOL_NARRATION_MIN_CHARS,
   ASSISTANT_POST_TELEGRAM_REPLY_MARKER,
+  ASSISTANT_COMPLETED_SUBAGENT_PROMPT_MARKER,
+  compactHistoricalCompletedSubagentPrompts,
   compactHistoricalPostTelegramReplyNarration,
   createAssistantMessagePreview,
   isSyntheticToolArguments,

package/bin/tool-result-offload-policy.cjs

@@ -13,6 +13,7 @@ const TOOL_RESULT_HISTORICAL_MIN_ITEM_CHARS = 600;
 const TOOL_RESULT_HISTORICAL_REPLACEMENT_BUDGET_CHARS = 600;
 const TOOL_RESULT_SUCCESS_KEEP_RECENT_MESSAGES = 12;
 const TOOL_RESULT_HISTORICAL_SUCCESS_MARKER = '[Old tool result content cleared]';
+const TOOL_RESULT_REPEAT_MARKER = '[Repeated tool result omitted]';
 
 function shouldOffloadToolResult(textLength) {
   return Number.isFinite(textLength) && textLength > TOOL_RESULT_MAX_CHARS;
@@ -102,6 +103,102 @@ function compactHistoricalSuccessfulToolResults(messages) {
   return changed ? projected : messages;
 }
 
+function toolCallSignaturesById(messages) {
+  const signatures = new Map();
+
+  for (const message of messages) {
+    if (!Array.isArray(message?.toolCalls)) continue;
+    for (const call of message.toolCalls) {
+      const id = call?.id ?? call?.toolCallId;
+      if (typeof id !== 'string' || typeof call?.name !== 'string') continue;
+      const args = typeof call.arguments === 'string'
+        ? call.arguments
+        : JSON.stringify(call.arguments ?? null);
+      signatures.set(id, `${call.name}\n${args}`);
+    }
+  }
+
+  return signatures;
+}
+
+function repeatedToolResultReference(newestToolCallId) {
+  return [
+    TOOL_RESULT_REPEAT_MARKER,
+    `same_as_tool_call_id: ${newestToolCallId}`,
+    'reason: identical successful result for the same tool call arguments',
+  ].join('\n');
+}
+
+function dedupeRepeatedSuccessfulToolResults(sourceMessages, projectedMessages = sourceMessages) {
+  if (
+    !Array.isArray(sourceMessages)
+    || !Array.isArray(projectedMessages)
+    || sourceMessages.length === 0
+    || sourceMessages.length !== projectedMessages.length
+  ) return projectedMessages;
+
+  const callSignatures = toolCallSignaturesById(sourceMessages);
+  const seenResultsByCall = new Map();
+  let changed = false;
+  const projected = projectedMessages.slice();
+
+  for (let index = sourceMessages.length - 1; index >= 0; index -= 1) {
+    const message = sourceMessages[index];
+    const toolCallId = message?.toolCallId;
+    if (
+      message?.role !== 'tool'
+      || message.isError === true
+      || typeof toolCallId !== 'string'
+      || !Array.isArray(message.content)
+      || message.content.length === 0
+      || isPersistedToolResultReference(message.content)
+      || !message.content.every((part) => part?.type === 'text' && typeof part.text === 'string')
+    ) continue;
+
+    const callSignature = callSignatures.get(toolCallId);
+    if (callSignature === undefined) continue;
+    const resultShape = message.content.length;
+    const resultSignature = resultShape === 1
+      ? message.content[0].text
+      : JSON.stringify(message.content.map((part) => part.text));
+    let seenResults = seenResultsByCall.get(callSignature);
+    if (seenResults === undefined) {
+      seenResults = new Map();
+      seenResultsByCall.set(callSignature, seenResults);
+    }
+    let seenResultsForShape = seenResults.get(resultShape);
+    if (seenResultsForShape === undefined) {
+      seenResultsForShape = new Map();
+      seenResults.set(resultShape, seenResultsForShape);
+    }
+    const newest = seenResultsForShape.get(resultSignature);
+    if (newest === undefined) {
+      seenResultsForShape.set(resultSignature, { toolCallId, index });
+      continue;
+    }
+
+    const reference = repeatedToolResultReference(newest.toolCallId);
+    const textChars = message.content.reduce((total, part) => total + part.text.length, 0);
+    const projectedMessage = projected[index];
+    if (
+      reference.length >= textChars
+      || projectedMessage?.role !== 'tool'
+      || projectedMessage.toolCallId !== toolCallId
+    ) continue;
+    projected[index] = {
+      ...projectedMessage,
+      content: [{ type: 'text', text: reference }],
+    };
+    projected[newest.index] = {
+      ...projected[newest.index],
+      content: sourceMessages[newest.index].content,
+    };
+    changed = true;
+  }
+
+  return changed ? projected : projectedMessages;
+}
+
 function selectToolResultBatchOffloads(textLengths) {
   if (!Array.isArray(textLengths) || textLengths.length < 2) return [];
 
@@ -170,6 +267,7 @@ module.exports = {
   TOOL_RESULT_HISTORICAL_MIN_ITEM_CHARS,
   TOOL_RESULT_HISTORICAL_REPLACEMENT_BUDGET_CHARS,
   TOOL_RESULT_HISTORICAL_SUCCESS_MARKER,
+  TOOL_RESULT_REPEAT_MARKER,
   TOOL_RESULT_MAX_CHARS,
   TOOL_RESULT_PREVIEW_CHARS,
   TOOL_RESULT_RECOVERY_PAGE_LINES,
@@ -178,6 +276,7 @@ module.exports = {
   compactHistoricalSuccessfulToolResults,
   compactPersistedToolResultReference,
   createToolResultPreview,
+  dedupeRepeatedSuccessfulToolResults,
   isPersistedToolResultReference,
   selectHistoricalToolResultOffloads,
   selectToolResultBatchOffloads,

package/blun.mjs

@@ -79000,7 +79000,7 @@ var init_context$2 = __esmMin((() => {
 			const historicalTelegramProjected = projectHistoricalUnaddressedTelegramMessages(duplicateUserMessagesProjected);
 			const assistantOffloaded = this.agent.assistantMessageOffload.compact(historicalTelegramProjected);
 			const repeatedAssistantProjected = projectRepeatedAssistantResponses(assistantOffloaded);
-			const result = project(this.agent.microCompaction.compact(compactHistoricalSuccessfulToolResults(this.agent.toolResultBatchOffload.compact(dedupeRecurringCronWakeups(dedupeRepeatedInjections(compactHistoricalSkillActivations(compactBaselineSkillInjections(repeatedAssistantProjected))))))), {
+			const result = project(this.agent.microCompaction.compact(compactHistoricalSuccessfulToolResults(dedupeRepeatedSuccessfulToolResults(repeatedAssistantProjected, this.agent.toolResultBatchOffload.compact(dedupeRecurringCronWakeups(dedupeRepeatedInjections(compactHistoricalSkillActivations(compactBaselineSkillInjections(repeatedAssistantProjected)))))))), {
 				...options,
 				onAnomaly: (anomaly) => {
 					anomalies.push(anomaly);
@@ -260553,7 +260553,7 @@ function renderHistoricalToolResultReference(toolName, toolCallId, text, outputP
 function safeToolResultFileStem(toolName, toolCallId) {
 	return `${toolName}-${toolCallId}`.replace(/[^a-zA-Z0-9._-]+/g, "_").replace(/^_+|_+$/g, "").slice(0, 80) || "tool-result";
 }
-var TOOL_RESULT_MAX_CHARS, TOOL_RESULT_PREVIEW_CHARS, TOOL_RESULT_RECOVERY_PAGE_LINES, TOOL_RESULT_OFFLOAD_MARKER, TOOL_RESULT_HISTORICAL_KEEP_RECENT_MESSAGES, shouldOffloadToolResult, createToolResultPreview, compactPersistedToolResultReference, compactHistoricalSuccessfulToolResults, selectToolResultBatchOffloads, selectHistoricalToolResultOffloads, buildToolResultOffloadTelemetry;
+var TOOL_RESULT_MAX_CHARS, TOOL_RESULT_PREVIEW_CHARS, TOOL_RESULT_RECOVERY_PAGE_LINES, TOOL_RESULT_OFFLOAD_MARKER, TOOL_RESULT_HISTORICAL_KEEP_RECENT_MESSAGES, shouldOffloadToolResult, createToolResultPreview, compactPersistedToolResultReference, compactHistoricalSuccessfulToolResults, dedupeRepeatedSuccessfulToolResults, selectToolResultBatchOffloads, selectHistoricalToolResultOffloads, buildToolResultOffloadTelemetry;
 var init_tool_result_budget = __esmMin((() => {
 	init_dist$6();
 	const toolResultOffloadPolicy = createRequire(import.meta.url)("./bin/tool-result-offload-policy.cjs");
@@ -260567,6 +260567,7 @@ var init_tool_result_budget = __esmMin((() => {
 	createToolResultPreview = toolResultOffloadPolicy.createToolResultPreview;
 	compactPersistedToolResultReference = toolResultOffloadPolicy.compactPersistedToolResultReference;
 	compactHistoricalSuccessfulToolResults = toolResultOffloadPolicy.compactHistoricalSuccessfulToolResults;
+	dedupeRepeatedSuccessfulToolResults = toolResultOffloadPolicy.dedupeRepeatedSuccessfulToolResults;
 	selectToolResultBatchOffloads = toolResultOffloadPolicy.selectToolResultBatchOffloads;
 	selectHistoricalToolResultOffloads = toolResultOffloadPolicy.selectHistoricalToolResultOffloads;
 }));
@@ -260894,7 +260895,7 @@ function renderPersistedAssistantMessage(text, outputPath) {
 		createAssistantMessagePreview(text)
 	].join("\n");
 }
-var ASSISTANT_MESSAGE_MAX_CHARS, ASSISTANT_MESSAGE_OFFLOAD_MARKER, ASSISTANT_TOOL_NARRATION_MARKER, shouldOffloadHistoricalAssistantMessage, shouldCompactHistoricalAssistantToolNarration, compactHistoricalPostTelegramReplyNarration, removeSyntheticToolArgumentFailures, createAssistantMessagePreview;
+var ASSISTANT_MESSAGE_MAX_CHARS, ASSISTANT_MESSAGE_OFFLOAD_MARKER, ASSISTANT_TOOL_NARRATION_MARKER, shouldOffloadHistoricalAssistantMessage, shouldCompactHistoricalAssistantToolNarration, compactHistoricalPostTelegramReplyNarration, compactHistoricalCompletedSubagentPrompts, removeSyntheticToolArgumentFailures, createAssistantMessagePreview;
 var init_assistant_message_offload = __esmMin((() => {
 	const policy = createRequire(import.meta.url)("./bin/assistant-message-offload-policy.cjs");
 	ASSISTANT_MESSAGE_MAX_CHARS = policy.ASSISTANT_MESSAGE_MAX_CHARS;
@@ -260903,6 +260904,7 @@ var init_assistant_message_offload = __esmMin((() => {
 	shouldOffloadHistoricalAssistantMessage = policy.shouldOffloadHistoricalAssistantMessage;
 	shouldCompactHistoricalAssistantToolNarration = policy.shouldCompactHistoricalAssistantToolNarration;
 	compactHistoricalPostTelegramReplyNarration = policy.compactHistoricalPostTelegramReplyNarration;
+	compactHistoricalCompletedSubagentPrompts = policy.compactHistoricalCompletedSubagentPrompts;
 	removeSyntheticToolArgumentFailures = policy.removeSyntheticToolArgumentFailures;
 	createAssistantMessagePreview = policy.createAssistantMessagePreview;
 }));
@@ -260990,7 +260992,8 @@ var AssistantMessageOffload = class {
 			return { ...message, content: replacement.content };
 		});
 		const narrationProjected = compactHistoricalPostTelegramReplyNarration(changed ? projected : messages);
-		return removeSyntheticToolArgumentFailures(narrationProjected);
+		const subagentProjected = compactHistoricalCompletedSubagentPrompts(narrationProjected);
+		return removeSyntheticToolArgumentFailures(subagentProjected);
 	}
 	reset(history = this.agent.context?.history ?? []) {
 		const activeHashes = new Set(history.map((message) => {

package/package.json

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