blun-king-cli 9.1.550 → 9.1.561

package/LIESMICH.txt

@@ -1,7 +1,7 @@
-BLUN Code 9.1.550
+BLUN Code 9.1.561
 
 Installation:
-  npm install -g blun-king-cli@9.1.550
+  npm install -g blun-king-cli@9.1.561
 
 Start:
   blun

package/README.md

@@ -11,7 +11,7 @@ web tools, MCP servers, and an optional Telegram channel.
 ## Install
 
 ```sh
-npm install -g blun-king-cli@9.1.550
+npm install -g blun-king-cli@9.1.561
 ```
 
 Start the local console with:

package/bin/compaction-transaction-policy.cjs

@@ -0,0 +1,122 @@
+'use strict';
+
+const { randomUUID } = require('node:crypto');
+
+function positiveInteger(value, label) {
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new TypeError(`${label} must be a non-negative safe integer`);
+  }
+  return value;
+}
+
+function toolCallId(call) {
+  return typeof call?.id === 'string' && call.id.length > 0 ? call.id : undefined;
+}
+
+function assertBalancedToolPairs(messages, label = 'compaction history') {
+  const pending = new Set();
+  for (const message of messages) {
+    if (message?.role === 'assistant') {
+      for (const call of message.toolCalls ?? []) {
+        const id = toolCallId(call);
+        if (id === undefined) throw new Error(`${label} contains a tool call without an id`);
+        if (pending.has(id)) throw new Error(`${label} contains duplicate tool call id ${id}`);
+        pending.add(id);
+      }
+      continue;
+    }
+    if (message?.role !== 'tool') continue;
+    const id = typeof message.toolCallId === 'string' ? message.toolCallId : undefined;
+    if (id === undefined || !pending.delete(id)) {
+      throw new Error(`${label} contains an orphan tool result${id ? ` ${id}` : ''}`);
+    }
+  }
+  if (pending.size > 0) {
+    throw new Error(`${label} contains ${pending.size} tool call(s) without results`);
+  }
+  return true;
+}
+
+function createCompactionTransaction({ source, turnId, tokensBefore, messageCountBefore }) {
+  const transaction = {
+    id: randomUUID(),
+    source,
+    turnId: turnId ?? null,
+    tokensBefore: positiveInteger(tokensBefore, 'tokensBefore'),
+    messageCountBefore: positiveInteger(messageCountBefore, 'messageCountBefore'),
+    state: 'started',
+  };
+  return {
+    transaction,
+    record: {
+      type: 'compaction/start',
+      compaction_id: transaction.id,
+      source: transaction.source,
+      turn_id: transaction.turnId,
+      size_before: transaction.tokensBefore,
+      message_count_before: transaction.messageCountBefore,
+      unit: 'tokens',
+    },
+  };
+}
+
+function summarizeCompactionTransaction(transaction, input) {
+  if (transaction?.state !== 'started') {
+    throw new Error('compaction/summary requires exactly one open compaction/start');
+  }
+  if (typeof input.summary !== 'string' || input.summary.trim().length === 0) {
+    throw new Error('compaction/summary requires non-empty model-visible summary text');
+  }
+  assertBalancedToolPairs(input.historyBefore, 'history before compaction');
+  assertBalancedToolPairs(input.historyAfter, 'history after compaction');
+  transaction.state = 'summarized';
+  transaction.tokensAfter = positiveInteger(input.tokensAfter, 'tokensAfter');
+  transaction.messageCountAfter = positiveInteger(input.messageCountAfter, 'messageCountAfter');
+  return {
+    type: 'compaction/summary',
+    compaction_id: transaction.id,
+    source: transaction.source,
+    turn_id: transaction.turnId,
+    summary: input.summary,
+    shadowed_token_count: transaction.tokensBefore,
+    size_before: transaction.tokensBefore,
+    size_after: transaction.tokensAfter,
+    message_count_before: transaction.messageCountBefore,
+    message_count_after: transaction.messageCountAfter,
+    tool_pairing_balanced_before: true,
+    tool_pairing_balanced_after: true,
+    unit: 'tokens',
+  };
+}
+
+function endCompactionTransaction(transaction, { status, error } = {}) {
+  if (transaction?.state === 'ended') return undefined;
+  if (transaction?.state !== 'started' && transaction?.state !== 'summarized') {
+    throw new Error('compaction/end requires an open compaction/start');
+  }
+  const normalizedStatus = status ?? 'success';
+  if (normalizedStatus === 'success' && transaction.state !== 'summarized') {
+    throw new Error('successful compaction/end requires one compaction/summary');
+  }
+  if (!['success', 'cancelled', 'failed'].includes(normalizedStatus)) {
+    throw new Error(`unsupported compaction status ${normalizedStatus}`);
+  }
+  transaction.state = 'ended';
+  return {
+    type: 'compaction/end',
+    compaction_id: transaction.id,
+    source: transaction.source,
+    turn_id: transaction.turnId,
+    status: normalizedStatus,
+    ...(transaction.tokensAfter === undefined ? {} : { size_after: transaction.tokensAfter }),
+    ...(typeof error === 'string' && error.length > 0 ? { error } : {}),
+    unit: 'tokens',
+  };
+}
+
+module.exports = {
+  assertBalancedToolPairs,
+  createCompactionTransaction,
+  endCompactionTransaction,
+  summarizeCompactionTransaction,
+};

package/bin/default-model-output-budget-policy.cjs

@@ -0,0 +1,28 @@
+'use strict';
+
+const DEFAULT_MODEL_ALIAS = 'blun/king';
+const DEFAULT_MAX_OUTPUT_SIZE = 128000;
+
+function applyDefaultModelOutputBudget(config) {
+  const models = config?.models;
+  const model = models?.[DEFAULT_MODEL_ALIAS];
+
+  if (!model || model.maxOutputSize !== undefined) return config;
+
+  return {
+    ...config,
+    models: {
+      ...models,
+      [DEFAULT_MODEL_ALIAS]: {
+        ...model,
+        maxOutputSize: DEFAULT_MAX_OUTPUT_SIZE,
+      },
+    },
+  };
+}
+
+module.exports = {
+  DEFAULT_MAX_OUTPUT_SIZE,
+  DEFAULT_MODEL_ALIAS,
+  applyDefaultModelOutputBudget,
+};

package/bin/file-observation-policy.cjs

@@ -0,0 +1,133 @@
+'use strict';
+
+function versionFromStat(stat) {
+  if (!stat || typeof stat !== 'object') return null;
+  return [
+    stat.stDev ?? null,
+    stat.stIno ?? null,
+    stat.stSize ?? null,
+    stat.stMtime ?? null,
+  ].join(':');
+}
+
+function isNotFoundError(error) {
+  return error?.code === 'ENOENT' || error?.code === 'ENOTDIR';
+}
+
+function createFileObservationPolicy(options = {}) {
+  const caseInsensitive = options.pathClass === 'win32';
+  const observations = new Map();
+
+  function key(filePath) {
+    const normalized = String(filePath).replaceAll('\\', '/');
+    return caseInsensitive ? normalized.toLowerCase() : normalized;
+  }
+
+  function recordPresent(filePath, stat) {
+    const version = versionFromStat(stat);
+    if (version === null) throw new TypeError('recordPresent requires a file stat');
+    observations.set(key(filePath), { kind: 'present', version });
+  }
+
+  function recordAbsent(filePath) {
+    observations.set(key(filePath), { kind: 'absent' });
+  }
+
+  function verifyStableRead(filePath, before, after) {
+    const beforeVersion = versionFromStat(before);
+    const afterVersion = versionFromStat(after);
+    if (beforeVersion === null || afterVersion === null || beforeVersion !== afterVersion) {
+      return {
+        allowed: false,
+        code: 'FS_STALE_VERSION',
+        error: `File changed while reading "${filePath}". Read it again before editing or overwriting it.`,
+      };
+    }
+    recordPresent(filePath, after);
+    return { allowed: true, version: afterVersion };
+  }
+
+  function authorizeEdit(filePath, currentStat) {
+    const prior = observations.get(key(filePath));
+    if (currentStat === null) {
+      return {
+        allowed: false,
+        code: prior?.kind === 'absent' ? 'FS_NOT_FOUND' : 'FS_NOT_OBSERVED',
+        error: prior?.kind === 'absent'
+          ? `Cannot edit "${filePath}": the last Read confirmed that it does not exist.`
+          : `Edit requires reading "${filePath}" first. Read the exact target path, then retry.`,
+      };
+    }
+    if (prior === undefined) {
+      return {
+        allowed: false,
+        code: 'FS_NOT_OBSERVED',
+        error: `Edit requires reading "${filePath}" first. Read the exact target path, then retry.`,
+      };
+    }
+    if (prior.kind !== 'present' || prior.version !== versionFromStat(currentStat)) {
+      return {
+        allowed: false,
+        code: 'FS_STALE_VERSION',
+        error: `"${filePath}" changed since the last Read. Read it again, then retry the Edit.`,
+      };
+    }
+    return { allowed: true, version: prior.version };
+  }
+
+  function authorizeWrite(filePath, currentStat) {
+    const prior = observations.get(key(filePath));
+    if (currentStat === null) {
+      if (prior?.kind === 'present') {
+        return {
+          allowed: false,
+          code: 'FS_STALE_VERSION',
+          error: `"${filePath}" disappeared since the last Read. Read it again before recreating it.`,
+        };
+      }
+      return { allowed: true, version: null, create: true };
+    }
+    if (prior === undefined) {
+      return {
+        allowed: false,
+        code: 'FS_NOT_OBSERVED',
+        error: `Write would replace or append to existing file "${filePath}" without a prior Read. Read it first, then retry.`,
+      };
+    }
+    if (prior.kind !== 'present' || prior.version !== versionFromStat(currentStat)) {
+      return {
+        allowed: false,
+        code: 'FS_STALE_VERSION',
+        error: `"${filePath}" changed since the last Read. Read it again, then retry the Write.`,
+      };
+    }
+    return { allowed: true, version: prior.version, create: false };
+  }
+
+  function verifyUnchanged(filePath, expectedVersion, currentStat) {
+    const currentVersion = versionFromStat(currentStat);
+    if (expectedVersion === currentVersion) return { allowed: true };
+    return {
+      allowed: false,
+      code: 'FS_STALE_VERSION',
+      error: expectedVersion === null
+        ? `"${filePath}" appeared before the new file could be created. Read it before deciding whether to overwrite it.`
+        : `"${filePath}" changed before the mutation was written. Read it again, then retry.`,
+    };
+  }
+
+  return {
+    authorizeEdit,
+    authorizeWrite,
+    recordAbsent,
+    recordPresent,
+    verifyStableRead,
+    verifyUnchanged,
+  };
+}
+
+module.exports = {
+  createFileObservationPolicy,
+  isNotFoundError,
+  versionFromStat,
+};

package/bin/launcher-runtime.js

@@ -539,7 +539,6 @@ async function runLauncher(options = {}) {
     env.BLUN_SHARED_HOME = privatePaths.sharedHome;
     env.BLUN_LOG_HOME = privatePaths.sharedHome;
     env.BLUN_PROFILE = PROFILE.profileName;
-    env.BLUN_MODEL_MAX_COMPLETION_TOKENS = env.BLUN_MODEL_MAX_COMPLETION_TOKENS || '32768';
     const mnemoConnect = startMnemoConnectHeartbeat({
       env,
       profileName: PROFILE.profileName,

package/bin/micro-compaction-policy.cjs

@@ -1,5 +1,7 @@
 'use strict';
 
+const { createHash } = require('node:crypto');
+
 const MICRO_COMPACTION_PRESSURE_RATIO = 0.75;
 const MICRO_COMPACTION_MIN_ADVANCE_MESSAGES = 20;
 const MICRO_COMPACTION_RECENT_MESSAGES = 4;
@@ -46,6 +48,66 @@ function selectMicroCompactionCutoff(options = {}) {
   };
 }
 
+function redundantHistoricalToolResultIds(messages, cutoff) {
+  return new Set(redundantHistoricalToolResultReferences(messages, cutoff).keys());
+}
+
+function redundantHistoricalToolResultReferences(messages, cutoff) {
+  if (!Array.isArray(messages)) return new Map();
+
+  const historicalCutoff = Math.min(messages.length, nonNegativeInteger(cutoff));
+  const callSignatures = new Map();
+  for (const message of messages) {
+    if (message?.role !== 'assistant' || !Array.isArray(message.toolCalls)) continue;
+    for (const call of message.toolCalls) {
+      if (
+        typeof call?.id !== 'string'
+        || typeof call.name !== 'string'
+        || typeof call.arguments !== 'string'
+      ) {
+        continue;
+      }
+      callSignatures.set(call.id, JSON.stringify([call.name, call.arguments]));
+    }
+  }
+
+  const resultsBySignature = new Map();
+  for (let index = 0; index < messages.length; index++) {
+    const message = messages[index];
+    if (message?.role !== 'tool' || typeof message.toolCallId !== 'string') continue;
+    const callSignature = callSignatures.get(message.toolCallId);
+    if (callSignature === undefined || !Array.isArray(message.content)) continue;
+
+    let resultSignature;
+    try {
+      resultSignature = createHash('sha256')
+        .update(callSignature)
+        .update('\0')
+        .update(JSON.stringify(message.content))
+        .digest('hex');
+    } catch {
+      continue;
+    }
+
+    const entries = resultsBySignature.get(resultSignature) ?? [];
+    entries.push({ index, toolCallId: message.toolCallId });
+    resultsBySignature.set(resultSignature, entries);
+  }
+
+  const redundantIds = new Map();
+  for (const entries of resultsBySignature.values()) {
+    if (entries.length < 2) continue;
+    const newestToolCallId = entries.at(-1)?.toolCallId;
+    if (newestToolCallId === undefined) continue;
+    for (const entry of entries.slice(0, -1)) {
+      if (entry.index < historicalCutoff) {
+        redundantIds.set(entry.toolCallId, newestToolCallId);
+      }
+    }
+  }
+  return redundantIds;
+}
+
 function finiteOr(value, fallback) {
   const number = Number(value);
   return Number.isFinite(number) ? number : fallback;
@@ -77,5 +139,7 @@ module.exports = {
   MICRO_COMPACTION_RECENT_MESSAGES,
   MICRO_COMPACTION_TOOL_ARGUMENTS_ENABLED,
   MICRO_COMPACTION_TOOL_ARGUMENT_MIN_TOKENS,
+  redundantHistoricalToolResultIds,
+  redundantHistoricalToolResultReferences,
   selectMicroCompactionCutoff,
 };

package/bin/mnemo-connect-heartbeat.cjs

@@ -5,7 +5,6 @@ const os = require('node:os');
 
 const DEFAULT_HEARTBEAT_MS = 60_000;
 const DEFAULT_TIMEOUT_MS = 5_000;
-const DEFAULT_INTERNAL_HUB_URL = 'http://100.85.21.103:7117';
 
 function resolveMnemoHubUrl(env = process.env) {
   const raw = [
@@ -51,7 +50,7 @@ function resolveMnemoProfileConnectConfig(configPath) {
     ].some((value) => typeof value === 'string' && value.trim().length > 0);
     const baseUrl = resolveMnemoHubUrl(server.env);
     if (configuredUrl && !baseUrl) return null;
-    return { agentName, baseUrl: baseUrl || DEFAULT_INTERNAL_HUB_URL };
+    return baseUrl ? { agentName, baseUrl } : null;
   } catch {
     return null;
   }
@@ -196,7 +195,6 @@ function startMnemoConnectHeartbeat(options = {}) {
 
 module.exports = {
   DEFAULT_HEARTBEAT_MS,
-  DEFAULT_INTERNAL_HUB_URL,
   DEFAULT_TIMEOUT_MS,
   postMnemoTool,
   resolveMnemoAgentName,

package/bin/retry-checkpoint-policy.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+async function persistRetrySchedule(input = {}) {
+  const { dispatchRetrying, flush, event, signal } = input;
+  if (typeof dispatchRetrying !== 'function') throw new TypeError('persistRetrySchedule requires dispatchRetrying');
+  if (typeof flush !== 'function') throw new TypeError('persistRetrySchedule requires flush');
+  signal?.throwIfAborted?.();
+  await dispatchRetrying(event);
+  await flush();
+  signal?.throwIfAborted?.();
+}
+
+module.exports = { persistRetrySchedule };

package/bin/session-checkpoint-policy.cjs

@@ -0,0 +1,25 @@
+'use strict';
+
+const TOOL_ABORTED_BEFORE_DISPATCH = 'TOOL_ABORTED_BEFORE_DISPATCH';
+
+async function checkpointBeforeExternalSideEffect(options = {}) {
+  const flush = options.flush;
+  const signal = options.signal;
+  if (typeof flush !== 'function') {
+    throw new TypeError('checkpointBeforeExternalSideEffect requires flush');
+  }
+  await flush();
+  if (signal?.aborted === true) {
+    return {
+      allowed: false,
+      code: TOOL_ABORTED_BEFORE_DISPATCH,
+      error: 'Tool call aborted before dispatch while its durable checkpoint was being written.',
+    };
+  }
+  return { allowed: true };
+}
+
+module.exports = {
+  TOOL_ABORTED_BEFORE_DISPATCH,
+  checkpointBeforeExternalSideEffect,
+};

package/bin/startup-preferences.cjs

@@ -125,6 +125,7 @@ function migrateLegacyStartupPreferences(profileHome, fsImpl = fs) {
 
 module.exports = {
   migrateLegacyStartupPreferences,
+  parseStartupPreferences,
   readStartupPreferences,
   resolveStartupUiLocale,
 };

package/bin/tool-file-persistence.cjs

@@ -0,0 +1,141 @@
+'use strict';
+
+const { randomBytes } = require('node:crypto');
+const fs = require('node:fs/promises');
+const path = require('node:path');
+
+const WINDOWS_RENAME_RETRY_CODES = new Set(['EACCES', 'EBUSY', 'EPERM']);
+const DEFAULT_WINDOWS_RENAME_DELAYS_MS = Object.freeze([10, 25, 50, 100]);
+
+function isAbortError(error) {
+  return error instanceof Error && error.name === 'AbortError';
+}
+
+function throwIfAborted(signal) {
+  if (!signal?.aborted) return;
+  const error = new Error('Atomic tool write aborted before publication.');
+  error.name = 'AbortError';
+  throw error;
+}
+
+function isMissing(error) {
+  return error?.code === 'ENOENT' || error?.code === 'ENOTDIR';
+}
+
+async function existingFileMode(filePath, statFile) {
+  try {
+    const info = await statFile(filePath);
+    if (!info.isFile()) throw Object.assign(new Error(`Cannot replace non-file target: ${filePath}`), { code: 'EISDIR' });
+    return typeof info.mode === 'number' ? info.mode & 0o777 : undefined;
+  } catch (error) {
+    if (isMissing(error)) return undefined;
+    throw error;
+  }
+}
+
+async function resolvePublicationPath(filePath, operations) {
+  try {
+    return await operations.realpathFile(filePath);
+  } catch (error) {
+    if (!isMissing(error)) throw error;
+  }
+
+  try {
+    const linkInfo = await operations.lstatFile(filePath);
+    if (linkInfo.isSymbolicLink()) {
+      throw Object.assign(new Error(`Refused atomic replacement through dangling symbolic link: ${filePath}`), { code: 'ELOOP' });
+    }
+  } catch (error) {
+    if (!isMissing(error)) throw error;
+  }
+
+  const realParent = await operations.realpathFile(path.dirname(filePath));
+  return path.join(realParent, path.basename(filePath));
+}
+
+async function renameWithWindowsRetry(source, target, options) {
+  const delays = options.platform === 'win32'
+    ? options.windowsRenameDelaysMs
+    : [];
+  let attempt = 0;
+  while (true) {
+    try {
+      await options.renameFile(source, target);
+      return;
+    } catch (error) {
+      const delayMs = delays[attempt];
+      if (delayMs === undefined || !WINDOWS_RENAME_RETRY_CODES.has(error?.code)) throw error;
+      attempt += 1;
+      throwIfAborted(options.signal);
+      await options.sleep(delayMs);
+    }
+  }
+}
+
+async function writeToolTextAtomic(filePath, content, options = {}) {
+  if (typeof filePath !== 'string' || filePath.length === 0) throw new TypeError('filePath must be a non-empty string');
+  if (typeof content !== 'string' && !Buffer.isBuffer(content)) throw new TypeError('content must be a string or Buffer');
+
+  const openFile = options.openFile || fs.open;
+  const renameFile = options.renameFile || fs.rename;
+  const unlinkFile = options.unlinkFile || fs.unlink;
+  const statFile = options.statFile || fs.stat;
+  const lstatFile = options.lstatFile || fs.lstat;
+  const realpathFile = options.realpathFile || fs.realpath;
+  const syncHandle = options.syncHandle || ((handle) => handle.sync());
+  const sleep = options.sleep || ((delayMs) => new Promise((resolve) => setTimeout(resolve, delayMs)));
+  const signal = options.signal;
+  const platform = options.platform || process.platform;
+  const windowsRenameDelaysMs = options.windowsRenameDelaysMs || DEFAULT_WINDOWS_RENAME_DELAYS_MS;
+
+  throwIfAborted(signal);
+  const publicationPath = await resolvePublicationPath(filePath, { lstatFile, realpathFile });
+  const mode = await existingFileMode(publicationPath, statFile);
+  const suffix = `${process.pid}.${randomBytes(6).toString('hex')}`;
+  const temporaryPath = path.join(path.dirname(publicationPath), `.${path.basename(publicationPath)}.${suffix}.tmp`);
+  let handle;
+  let published = false;
+
+  try {
+    handle = await openFile(temporaryPath, 'wx', mode ?? 0o666);
+    await handle.writeFile(content, typeof content === 'string' ? { encoding: 'utf8', signal } : { signal });
+    await syncHandle(handle);
+    if (mode !== undefined && platform !== 'win32') await handle.chmod(mode);
+    await handle.close();
+    handle = undefined;
+
+    throwIfAborted(signal);
+    await renameWithWindowsRetry(temporaryPath, publicationPath, {
+      platform,
+      renameFile,
+      signal,
+      sleep,
+      windowsRenameDelaysMs,
+    });
+    published = true;
+    return { bytesWritten: Buffer.byteLength(content) };
+  } finally {
+    if (handle !== undefined) {
+      try {
+        await handle.close();
+      } catch {}
+    }
+    if (!published) {
+      try {
+        await unlinkFile(temporaryPath);
+      } catch (error) {
+        if (!isMissing(error)) {
+          // The primary write error remains authoritative; stale temp names are unique and never read.
+        }
+      }
+    }
+  }
+}
+
+module.exports = {
+  DEFAULT_WINDOWS_RENAME_DELAYS_MS,
+  WINDOWS_RENAME_RETRY_CODES,
+  renameWithWindowsRetry,
+  resolvePublicationPath,
+  writeToolTextAtomic,
+};

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

@@ -28,8 +28,10 @@ function hasToolResultOffloadPressure(options = {}) {
   return hasContextPressure(options);
 }
 
-function shouldOffloadToolResult(textLength) {
-  return Number.isFinite(textLength) && textLength > TOOL_RESULT_MAX_CHARS;
+function shouldOffloadToolResult(textLength, options = {}) {
+  return Number.isFinite(textLength)
+    && textLength > TOOL_RESULT_MAX_CHARS
+    && hasToolResultOffloadPressure(options);
 }
 
 function shouldKeepFreshToolResult(toolName) {
@@ -165,33 +167,8 @@ function compactPersistedToolResultReference(content) {
 }
 
 function compactHistoricalSuccessfulToolResults(messages, options = {}) {
-  if (!Array.isArray(messages) || messages.length === 0) return messages;
-  if (!hasToolResultOffloadPressure(options)) return messages;
-
-  const recentStart = Math.max(0, messages.length - TOOL_RESULT_SUCCESS_KEEP_RECENT_MESSAGES);
-  const freshIds = freshToolResultIds(messages);
-  let changed = false;
-  const projected = messages.map((message, index) => {
-    if (
-      index >= recentStart
-      || message?.role !== 'tool'
-      || freshIds.has(message.toolCallId)
-      || message.isError === true
-      || !Array.isArray(message.content)
-      || isPersistedToolResultReference(message.content)
-      || !message.content.every((part) => part?.type === 'text' && typeof part.text === 'string')
-    ) return message;
-
-    const textChars = message.content.reduce((total, part) => total + part.text.length, 0);
-    if (textChars <= TOOL_RESULT_HISTORICAL_SUCCESS_MARKER.length) return message;
-    changed = true;
-    return {
-      ...message,
-      content: [{ type: 'text', text: TOOL_RESULT_HISTORICAL_SUCCESS_MARKER }],
-    };
-  });
-
-  return changed ? projected : messages;
+  void options;
+  return messages;
 }
 
 function toolCallSignaturesById(messages) {
@@ -280,10 +257,12 @@ function dedupeRepeatedSuccessfulToolResults(sourceMessages, projectedMessages =
       ...projectedMessage,
       content: [{ type: 'text', text: reference }],
     };
-    projected[newest.index] = {
-      ...projected[newest.index],
-      content: sourceMessages[newest.index].content,
-    };
+    if (projected[newest.index] !== sourceMessages[newest.index]) {
+      projected[newest.index] = {
+        ...projected[newest.index],
+        content: sourceMessages[newest.index].content,
+      };
+    }
     changed = true;
   }