blun-king-cli 9.1.233 → 9.1.234

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

package/package.json

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