@dexto/core 1.3.0 → 1.5.0

package/dist/context/utils.cjs

@@ -18,10 +18,12 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var utils_exports = {};
 __export(utils_exports, {
-  countMessagesTokens: () => countMessagesTokens,
+  estimateMessagesTokens: () => estimateMessagesTokens,
   expandBlobReferences: () => expandBlobReferences,
   fileTypesToMimePatterns: () => fileTypesToMimePatterns,
+  filterCompacted: () => filterCompacted,
   filterMessagesByLLMCapabilities: () => filterMessagesByLLMCapabilities,
+  formatToolOutputForDisplay: () => formatToolOutputForDisplay,
   getFileData: () => getFileData,
   getFileDataWithBlobSupport: () => getFileDataWithBlobSupport,
   getFileMediaKind: () => import_media_helpers.getFileMediaKind,
@@ -40,11 +42,11 @@ __export(utils_exports, {
   toTextForToolMessage: () => toTextForToolMessage
 });
 module.exports = __toCommonJS(utils_exports);
+var import_types = require("./types.js");
+var import_display_types = require("../tools/display-types.js");
 var import_registry = require("../llm/registry.cjs");
-var import_errors = require("./errors.js");
 var import_safe_stringify = require("../utils/safe-stringify.cjs");
 var import_media_helpers = require("./media-helpers.js");
-const DEFAULT_OVERHEAD_PER_MESSAGE = 4;
 const MIN_BASE64_HEURISTIC_LENGTH = 512;
 const MAX_TOOL_TEXT_CHARS = 8e3;
 const MIN_TOOL_INLINE_MEDIA_BYTES = 1024;
@@ -92,60 +94,38 @@ function clonePart(part) {
   return cloned;
 }
 function coerceContentToParts(content) {
-  if (Array.isArray(content)) {
-    const normalized = [];
-    for (const item of content) {
-      if (item == null) continue;
-      if (typeof item === "string") {
-        normalized.push({ type: "text", text: item });
-        continue;
+  if (content == null) {
+    return [];
+  }
+  const normalized = [];
+  for (const item of content) {
+    if (item.type === "ui-resource") {
+      continue;
+    }
+    if (item.type === "text") {
+      normalized.push({ type: "text", text: item.text });
+    } else if (item.type === "image") {
+      const cloned = {
+        type: "image",
+        image: item.image
+      };
+      if (item.mimeType) {
+        cloned.mimeType = item.mimeType;
       }
-      if (typeof item === "object" && "type" in item) {
-        const type = item.type;
-        if (type === "text") {
-          const textPart = item;
-          normalized.push({ type: "text", text: textPart.text });
-          continue;
-        }
-        if (type === "image") {
-          const imagePart = item;
-          const cloned = {
-            type: "image",
-            image: imagePart.image
-          };
-          if (imagePart.mimeType) {
-            cloned.mimeType = imagePart.mimeType;
-          }
-          normalized.push(cloned);
-          continue;
-        }
-        if (type === "file") {
-          const filePart = item;
-          const cloned = {
-            type: "file",
-            data: filePart.data,
-            mimeType: filePart.mimeType ?? "application/octet-stream"
-          };
-          if (filePart.filename) {
-            cloned.filename = filePart.filename;
-          }
-          normalized.push(cloned);
-          continue;
-        }
+      normalized.push(cloned);
+    } else if (item.type === "file") {
+      const cloned = {
+        type: "file",
+        data: item.data,
+        mimeType: item.mimeType ?? "application/octet-stream"
+      };
+      if (item.filename) {
+        cloned.filename = item.filename;
       }
+      normalized.push(cloned);
     }
-    return normalized;
-  }
-  if (typeof content === "string") {
-    if (content.length === 0) {
-      return [];
-    }
-    return [{ type: "text", text: content }];
   }
-  if (content == null) {
-    return [];
-  }
-  return [{ type: "text", text: (0, import_safe_stringify.safeStringify)(content) }];
+  return normalized;
 }
 function detectInlineMedia(part, index) {
   if (part.type === "text") {
@@ -304,17 +284,16 @@ async function resolveBlobReferenceToParts(resourceUri, resourceManager, logger,
         parts.push({ type: "text", text: item.text });
         continue;
       }
-      const base64Data = typeof item.blob === "string" ? item.blob : typeof item.data === "string" ? item.data : void 0;
+      const base64Data = "blob" in item && typeof item.blob === "string" ? item.blob : "data" in item && typeof item.data === "string" ? item.data : void 0;
       const mimeType = typeof item.mimeType === "string" ? item.mimeType : void 0;
       if (!base64Data || !mimeType) {
         continue;
       }
       const resolvedMime = mimeType ?? "application/octet-stream";
       if (resolvedMime.startsWith("image/")) {
-        const dataUri = `data:${resolvedMime};base64,${base64Data}`;
         const imagePart = {
           type: "image",
-          image: dataUri,
+          image: base64Data,
           mimeType: resolvedMime
         };
         parts.push(imagePart);
@@ -322,11 +301,12 @@ async function resolveBlobReferenceToParts(resourceUri, resourceManager, logger,
       }
       const filePart = {
         type: "file",
-        data: resolvedMime.startsWith("audio/") ? `data:${resolvedMime};base64,${base64Data}` : base64Data,
+        data: base64Data,
         mimeType: resolvedMime
       };
-      if (typeof item.filename === "string" && item.filename.length > 0) {
-        filePart.filename = item.filename;
+      const itemWithFilename = item;
+      if (typeof itemWithFilename.filename === "string" && itemWithFilename.filename.length > 0) {
+        filePart.filename = itemWithFilename.filename;
       } else if (typeof result._meta?.originalName === "string") {
         filePart.filename = result._meta.originalName;
       }
@@ -342,67 +322,17 @@ async function resolveBlobReferenceToParts(resourceUri, resourceManager, logger,
     return [{ type: "text", text: `[Attachment unavailable: ${resourceUri}]` }];
   }
 }
-function countMessagesTokens(history, tokenizer, overheadPerMessage = DEFAULT_OVERHEAD_PER_MESSAGE, logger) {
-  let total = 0;
-  logger.debug(`Counting tokens for ${history.length} messages`);
-  try {
-    for (const message of history) {
-      if (message.content) {
-        if (typeof message.content === "string") {
-          total += tokenizer.countTokens(message.content);
-        } else if (Array.isArray(message.content)) {
-          message.content.forEach((part) => {
-            if (part.type === "text" && typeof part.text === "string") {
-              total += tokenizer.countTokens(part.text);
-            } else if (part.type === "image") {
-              if (typeof part.image === "string") {
-                if (isDataUri(part.image)) {
-                  const base64Payload = extractBase64FromDataUri(part.image);
-                  const byteLength = base64LengthToBytes(base64Payload.length);
-                  total += Math.ceil(byteLength / 1024);
-                } else {
-                  total += estimateTextTokens(part.image);
-                }
-              } else if (part.image instanceof Uint8Array || part.image instanceof Buffer || part.image instanceof ArrayBuffer) {
-                const bytes = part.image instanceof ArrayBuffer ? part.image.byteLength : part.image.length;
-                total += Math.ceil(bytes / 1024);
-              }
-            } else if (part.type === "file") {
-              if (typeof part.data === "string") {
-                if (isDataUri(part.data)) {
-                  const base64Payload = extractBase64FromDataUri(part.data);
-                  const byteLength = base64LengthToBytes(base64Payload.length);
-                  total += Math.ceil(byteLength / 1024);
-                } else {
-                  total += estimateTextTokens(part.data);
-                }
-              } else if (part.data instanceof Uint8Array || part.data instanceof Buffer || part.data instanceof ArrayBuffer) {
-                const bytes = part.data instanceof ArrayBuffer ? part.data.byteLength : part.data.length;
-                total += Math.ceil(bytes / 1024);
-              }
-            }
-          });
-        }
-      }
-      if (message.toolCalls) {
-        for (const call of message.toolCalls) {
-          if (call.function?.name) {
-            total += tokenizer.countTokens(call.function.name);
-          }
-          if (call.function?.arguments) {
-            total += tokenizer.countTokens(call.function.arguments);
-          }
-        }
-      }
-      total += overheadPerMessage;
+function estimateMessagesTokens(messages) {
+  return messages.reduce((sum, msg) => {
+    if (Array.isArray(msg.content)) {
+      return sum + msg.content.reduce((partSum, part) => {
+        if (part.type === "text") return partSum + Math.ceil(part.text.length / 4);
+        if (part.type === "image" || part.type === "file") return partSum + 1e3;
+        return partSum;
+      }, 0);
     }
-  } catch (error) {
-    logger.error(
-      `countMessagesTokens failed: ${error instanceof Error ? error.message : String(error)}`
-    );
-    throw import_errors.ContextError.tokenCountFailed(error instanceof Error ? error.message : String(error));
-  }
-  return total;
+    return sum;
+  }, 0);
 }
 function getImageData(imagePart, logger) {
   const { image } = imagePart;
@@ -443,8 +373,9 @@ async function getImageDataWithBlobSupport(imagePart, resourceManager, logger) {
       const uri = image.substring(1);
       const resourceUri = uri.startsWith("blob:") ? uri : `blob:${uri}`;
       const result = await resourceManager.read(resourceUri);
-      if (result.contents[0]?.blob && typeof result.contents[0].blob === "string") {
-        return result.contents[0].blob;
+      const firstContent = result.contents[0];
+      if (firstContent && "blob" in firstContent && firstContent.blob && typeof firstContent.blob === "string") {
+        return firstContent.blob;
       }
       logger.warn(`Blob reference ${image} did not contain blob data`);
     } catch (error) {
@@ -460,8 +391,9 @@ async function getFileDataWithBlobSupport(filePart, resourceManager, logger) {
       const uri = data.substring(1);
       const resourceUri = uri.startsWith("blob:") ? uri : `blob:${uri}`;
       const result = await resourceManager.read(resourceUri);
-      if (result.contents[0]?.blob && typeof result.contents[0].blob === "string") {
-        return result.contents[0].blob;
+      const firstContent = result.contents[0];
+      if (firstContent && "blob" in firstContent && firstContent.blob && typeof firstContent.blob === "string") {
+        return firstContent.blob;
       }
       logger.warn(`Blob reference ${data} did not contain blob data`);
     } catch (error) {
@@ -470,122 +402,119 @@ async function getFileDataWithBlobSupport(filePart, resourceManager, logger) {
   }
   return getFileData(filePart, logger);
 }
-async function expandBlobReferences(content, resourceManager, logger, allowedMediaTypes) {
-  if (typeof content === "string") {
-    const blobRefPattern = /@blob:[a-f0-9]+/g;
-    const matches = [...content.matchAll(blobRefPattern)];
-    if (matches.length === 0) {
-      return content;
-    }
-    const resolvedCache = /* @__PURE__ */ new Map();
-    const parts = [];
-    let lastIndex = 0;
-    for (const match of matches) {
-      const matchIndex = match.index ?? 0;
-      const token = match[0];
-      if (matchIndex > lastIndex) {
-        const segment = content.slice(lastIndex, matchIndex);
-        if (segment.length > 0) {
-          parts.push({ type: "text", text: segment });
-        }
-      }
-      const uri = token.substring(1);
-      const resourceUri = uri.startsWith("blob:") ? uri : `blob:${uri}`;
-      let resolvedParts = resolvedCache.get(resourceUri);
-      if (!resolvedParts) {
-        resolvedParts = await resolveBlobReferenceToParts(
-          resourceUri,
-          resourceManager,
-          logger,
-          allowedMediaTypes
-        );
-        resolvedCache.set(resourceUri, resolvedParts);
-      }
-      if (resolvedParts.length > 0) {
-        parts.push(...resolvedParts.map((part) => ({ ...part })));
-      } else {
-        parts.push({ type: "text", text: token });
+async function expandBlobsInText(text, resourceManager, logger, allowedMediaTypes) {
+  if (!text.includes("@blob:")) {
+    return [{ type: "text", text }];
+  }
+  const blobRefPattern = /@blob:[a-f0-9]+/g;
+  const matches = [...text.matchAll(blobRefPattern)];
+  if (matches.length === 0) {
+    return [{ type: "text", text }];
+  }
+  const resolvedCache = /* @__PURE__ */ new Map();
+  const parts = [];
+  let lastIndex = 0;
+  for (const match of matches) {
+    const matchIndex = match.index ?? 0;
+    const token = match[0];
+    if (matchIndex > lastIndex) {
+      const segment = text.slice(lastIndex, matchIndex);
+      if (segment.length > 0) {
+        parts.push({ type: "text", text: segment });
       }
-      lastIndex = matchIndex + token.length;
     }
-    if (lastIndex < content.length) {
-      const trailing = content.slice(lastIndex);
-      if (trailing.length > 0) {
-        parts.push({ type: "text", text: trailing });
-      }
+    const uri = token.substring(1);
+    const resourceUri = uri.startsWith("blob:") ? uri : `blob:${uri}`;
+    let resolvedParts = resolvedCache.get(resourceUri);
+    if (!resolvedParts) {
+      resolvedParts = await resolveBlobReferenceToParts(
+        resourceUri,
+        resourceManager,
+        logger,
+        allowedMediaTypes
+      );
+      resolvedCache.set(resourceUri, resolvedParts);
     }
-    const normalized = parts.filter((part) => part.type !== "text" || part.text.length > 0);
-    if (normalized.length === 1 && normalized[0]?.type === "text") {
-      return normalized[0].text;
+    if (resolvedParts.length > 0) {
+      parts.push(...resolvedParts.map((p) => ({ ...p })));
+    } else {
+      parts.push({ type: "text", text: token });
     }
-    return normalized;
+    lastIndex = matchIndex + token.length;
   }
-  if (Array.isArray(content)) {
-    const expandedParts = [];
-    for (const part of content) {
-      if (part.type === "image" && typeof part.image === "string" && part.image.startsWith("@blob:")) {
-        const uri = part.image.substring(1);
-        const resourceUri = uri.startsWith("blob:") ? uri : `blob:${uri}`;
-        const resolved = await resolveBlobReferenceToParts(
-          resourceUri,
-          resourceManager,
-          logger,
-          allowedMediaTypes
-        );
-        if (resolved.length > 0) {
-          expandedParts.push(...resolved.map((part2) => ({ ...part2 })));
-        } else {
-          expandedParts.push(part);
-        }
-        continue;
-      }
-      if (part.type === "file" && typeof part.data === "string" && part.data.startsWith("@blob:")) {
-        const uri = part.data.substring(1);
-        const resourceUri = uri.startsWith("blob:") ? uri : `blob:${uri}`;
-        const resolved = await resolveBlobReferenceToParts(
-          resourceUri,
-          resourceManager,
-          logger,
-          allowedMediaTypes
-        );
-        if (resolved.length > 0) {
-          expandedParts.push(...resolved.map((part2) => ({ ...part2 })));
-        } else {
-          try {
-            const resolvedData = await getFileDataWithBlobSupport(
-              part,
-              resourceManager,
-              logger
-            );
-            expandedParts.push({ ...part, data: resolvedData });
-          } catch (error) {
-            logger.warn(`Failed to resolve file blob reference: ${String(error)}`);
-            expandedParts.push(part);
-          }
-        }
-        continue;
+  if (lastIndex < text.length) {
+    const trailing = text.slice(lastIndex);
+    if (trailing.length > 0) {
+      parts.push({ type: "text", text: trailing });
+    }
+  }
+  return parts.filter((p) => p.type !== "text" || p.text.length > 0);
+}
+async function expandBlobReferences(content, resourceManager, logger, allowedMediaTypes) {
+  if (content == null || !Array.isArray(content)) {
+    return [];
+  }
+  const expandedParts = [];
+  for (const part of content) {
+    if (part.type === "ui-resource") {
+      expandedParts.push(part);
+      continue;
+    }
+    if (part.type === "image" && typeof part.image === "string" && part.image.startsWith("@blob:")) {
+      const uri = part.image.substring(1);
+      const resourceUri = uri.startsWith("blob:") ? uri : `blob:${uri}`;
+      const resolved = await resolveBlobReferenceToParts(
+        resourceUri,
+        resourceManager,
+        logger,
+        allowedMediaTypes
+      );
+      if (resolved.length > 0) {
+        expandedParts.push(...resolved.map((p) => ({ ...p })));
+      } else {
+        expandedParts.push(part);
       }
-      if (part.type === "text" && part.text.includes("@blob:")) {
-        const expanded = await expandBlobReferences(
-          part.text,
-          resourceManager,
-          logger,
-          allowedMediaTypes
-        );
-        if (typeof expanded === "string") {
-          expandedParts.push({ ...part, text: expanded });
-        } else if (Array.isArray(expanded)) {
-          expandedParts.push(...expanded.map((part2) => ({ ...part2 })));
-        } else {
+      continue;
+    }
+    if (part.type === "file" && typeof part.data === "string" && part.data.startsWith("@blob:")) {
+      const uri = part.data.substring(1);
+      const resourceUri = uri.startsWith("blob:") ? uri : `blob:${uri}`;
+      const resolved = await resolveBlobReferenceToParts(
+        resourceUri,
+        resourceManager,
+        logger,
+        allowedMediaTypes
+      );
+      if (resolved.length > 0) {
+        expandedParts.push(...resolved.map((p) => ({ ...p })));
+      } else {
+        try {
+          const resolvedData = await getFileDataWithBlobSupport(
+            part,
+            resourceManager,
+            logger
+          );
+          expandedParts.push({ ...part, data: resolvedData });
+        } catch (error) {
+          logger.warn(`Failed to resolve file blob reference: ${String(error)}`);
           expandedParts.push(part);
         }
-        continue;
       }
-      expandedParts.push(part);
+      continue;
+    }
+    if (part.type === "text" && part.text.includes("@blob:")) {
+      const expanded = await expandBlobsInText(
+        part.text,
+        resourceManager,
+        logger,
+        allowedMediaTypes
+      );
+      expandedParts.push(...expanded);
+      continue;
     }
-    return expandedParts;
+    expandedParts.push(part);
   }
-  return content;
+  return expandedParts;
 }
 function filterMessagesByLLMCapabilities(messages, config, logger) {
   try {
@@ -729,7 +658,25 @@ async function normalizeToolResult(result, logger) {
     void 0,
     void 0
   );
-  const parts = coerceContentToParts(content);
+  const uiResources = [];
+  const otherContent = [];
+  if (Array.isArray(content)) {
+    for (const item of content) {
+      if (item && typeof item === "object" && "type" in item && item.type === "ui-resource") {
+        uiResources.push(item);
+      } else {
+        otherContent.push(item);
+      }
+    }
+  } else {
+    otherContent.push(content);
+  }
+  if (uiResources.length > 0) {
+    logger.debug(
+      `normalizeToolResult: extracted ${uiResources.length} UI resource(s): ${uiResources.map((r) => r.uri).join(", ")}`
+    );
+  }
+  const parts = coerceContentToParts(otherContent);
   const inlineMedia = [];
   parts.forEach((part, index) => {
     const hint = detectInlineMedia(part, index);
@@ -739,6 +686,7 @@ async function normalizeToolResult(result, logger) {
   });
   return {
     parts,
+    uiResources,
     inlineMedia
   };
 }
@@ -756,6 +704,7 @@ async function persistToolMedia(normalized, options, logger) {
     ...options.toolName ? { toolName: options.toolName } : {},
     ...options.toolCallId ? { toolCallId: options.toolCallId } : {}
   } : void 0;
+  const storedBlobs = [];
   if (blobStore) {
     for (const hint of normalized.inlineMedia) {
       if (!shouldPersistInlineMedia(hint)) {
@@ -780,6 +729,14 @@ async function persistToolMedia(normalized, options, logger) {
           const filename = blobRef.metadata.originalName ?? hint.filename;
           parts[hint.index] = createBlobFilePart(resourceUri, resolvedMimeType, filename);
         }
+        storedBlobs.push({
+          uri: resourceUri,
+          kind: hint.kind,
+          mimeType: blobRef.metadata.mimeType,
+          ...blobRef.metadata.originalName && {
+            filename: blobRef.metadata.originalName
+          }
+        });
       } catch (error) {
         logger.warn(
           `Failed to persist tool media: ${error instanceof Error ? error.message : String(error)}`
@@ -787,9 +744,18 @@ async function persistToolMedia(normalized, options, logger) {
       }
     }
   }
+  if (storedBlobs.length > 0) {
+    const annotations = storedBlobs.map((blob) => {
+      const label = blob.filename || blob.kind;
+      return `[Stored resource_ref:${blob.uri} (${label}, ${blob.mimeType})]`;
+    }).join("\n");
+    parts.push({ type: "text", text: annotations });
+    logger.debug(`Added blob reference annotations for ${storedBlobs.length} resource(s)`);
+  }
   const resources = extractResourceDescriptors(parts);
   return {
     parts,
+    uiResources: normalized.uiResources,
     ...resources ? { resources } : {}
   };
 }
@@ -836,53 +802,22 @@ async function sanitizeToolResultToContentWithBlobs(result, logger, blobStore, n
           }
         ];
       }
-      if (isLikelyBase64String(result)) {
-        logger.debug("sanitizeToolResultToContentWithBlobs: detected base64-like string");
-        const approxSize = Math.floor(result.length * 3 / 4);
-        const shouldStoreAsBlob = blobStore && approxSize > 1024;
-        if (shouldStoreAsBlob) {
-          try {
-            const blobRef = await blobStore.store(result, {
-              mimeType: "application/octet-stream",
-              source: "tool",
-              originalName: buildToolBlobName("output", void 0, namingOptions)
-            });
-            logger.debug(
-              `Stored tool result as blob: ${blobRef.uri} (${approxSize} bytes)`
-            );
-            return [
-              createBlobFilePart(
-                blobRef.uri,
-                "application/octet-stream",
-                "tool-output.bin"
-              )
-            ];
-          } catch (error) {
-            logger.warn(
-              `Failed to store blob, falling back to inline: ${String(error)}`
-            );
-          }
-        }
-        return [
-          {
-            type: "file",
-            data: result,
-            mimeType: "application/octet-stream",
-            filename: "tool-output.bin"
-          }
-        ];
-      }
       if (result.length > MAX_TOOL_TEXT_CHARS) {
         const head = result.slice(0, 4e3);
         const tail = result.slice(-1e3);
         logger.debug(
           `sanitizeToolResultToContentWithBlobs: truncating long text tool output (len=${result.length})`
         );
-        return `${head}
+        return [
+          {
+            type: "text",
+            text: `${head}
 ... [${result.length - 5e3} chars omitted] ...
-${tail}`;
+${tail}`
+          }
+        ];
       }
-      return result;
+      return [{ type: "text", text: result }];
     }
     if (Array.isArray(result)) {
       const parts = [];
@@ -894,10 +829,10 @@ ${tail}`;
           blobStore,
           namingOptions
         );
-        if (typeof processedItem === "string") {
-          parts.push({ type: "text", text: processedItem });
-        } else if (Array.isArray(processedItem)) {
-          parts.push(...processedItem);
+        if (Array.isArray(processedItem)) {
+          parts.push(
+            ...processedItem
+          );
         }
       }
       return parts;
@@ -911,6 +846,34 @@ ${tail}`;
         const processedContent = [];
         for (const item of anyObj.content) {
           if (item && typeof item === "object") {
+            if (item.type === "resource" && item.resource) {
+              const resource = item.resource;
+              const resourceUri = resource.uri;
+              if (resourceUri && resourceUri.startsWith("ui://")) {
+                logger.debug(
+                  `Detected MCP-UI resource: ${resourceUri} (${resource.mimeType})`
+                );
+                const resourceMeta = resource._meta || {};
+                const title = resourceMeta.title || resource.title;
+                const preferredSize = resourceMeta.preferredSize || resource.preferredSize;
+                const uiPart = {
+                  type: "ui-resource",
+                  uri: resourceUri,
+                  mimeType: resource.mimeType || "text/html",
+                  content: resource.text,
+                  blob: resource.blob,
+                  metadata: {
+                    title,
+                    preferredSize
+                  }
+                };
+                if (!uiPart.metadata?.title && !uiPart.metadata?.preferredSize) {
+                  delete uiPart.metadata;
+                }
+                processedContent.push(uiPart);
+                continue;
+              }
+            }
             if (item.type === "resource" && item.resource) {
               const resource = item.resource;
               if (resource.text && resource.mimeType) {
@@ -1107,17 +1070,17 @@ ${tail}`;
         ];
       }
       const cleaned = sanitizeDeepObject(anyObj, logger);
-      return (0, import_safe_stringify.safeStringify)(cleaned);
+      return [{ type: "text", text: (0, import_safe_stringify.safeStringify)(cleaned) }];
     }
-    return (0, import_safe_stringify.safeStringify)(result ?? "");
+    return [{ type: "text", text: (0, import_safe_stringify.safeStringify)(result ?? "") }];
   } catch (err) {
     logger.warn(
       `sanitizeToolResultToContentWithBlobs failed, falling back to string: ${String(err)}`
     );
     try {
-      return (0, import_safe_stringify.safeStringify)(result ?? "");
+      return [{ type: "text", text: (0, import_safe_stringify.safeStringify)(result ?? "") }];
     } catch {
-      return String(result ?? "");
+      return [{ type: "text", text: String(result ?? "") }];
     }
   }
 }
@@ -1161,7 +1124,19 @@ function extractResourceDescriptors(parts) {
   return resources.length > 0 ? resources : void 0;
 }
 async function sanitizeToolResult(result, options, logger) {
-  const normalized = await normalizeToolResult(result, logger);
+  let display;
+  let resultForNormalization = result;
+  if (result && typeof result === "object" && "_display" in result) {
+    const { _display: rawDisplay, ...rest } = result;
+    if ((0, import_display_types.isValidDisplayData)(rawDisplay)) {
+      display = rawDisplay;
+      logger.debug(
+        `sanitizeToolResult: extracted display data (type=${display.type}) for ${options.toolName}`
+      );
+    }
+    resultForNormalization = rest;
+  }
+  const normalized = await normalizeToolResult(resultForNormalization, logger);
   const persisted = await persistToolMedia(
     normalized,
     {
@@ -1172,14 +1147,24 @@ async function sanitizeToolResult(result, options, logger) {
     logger
   );
   const fallbackContent = [{ type: "text", text: "" }];
-  const content = persisted.parts.length > 0 ? persisted.parts : fallbackContent;
+  const allContent = [
+    ...persisted.parts,
+    ...persisted.uiResources
+  ];
+  const content = allContent.length > 0 ? allContent : fallbackContent;
+  if (persisted.uiResources.length > 0) {
+    logger.debug(
+      `sanitizeToolResult: including ${persisted.uiResources.length} UI resource(s) in final content for ${options.toolName}`
+    );
+  }
   return {
     content,
     ...persisted.resources ? { resources: persisted.resources } : {},
     meta: {
       toolName: options.toolName,
       toolCallId: options.toolCallId,
-      ...typeof options.success === "boolean" ? { success: options.success } : {}
+      success: options.success,
+      ...display ? { display } : {}
     }
   };
 }
@@ -1212,16 +1197,6 @@ function summarizeToolContentForText(content) {
 function base64LengthToBytes(charLength) {
   return Math.floor(charLength * 3 / 4);
 }
-function isDataUri(str) {
-  return str.startsWith("data:") && str.includes(";base64,");
-}
-function extractBase64FromDataUri(dataUri) {
-  const commaIndex = dataUri.indexOf(",");
-  return commaIndex !== -1 ? dataUri.substring(commaIndex + 1) : "";
-}
-function estimateTextTokens(text) {
-  return Math.ceil(text.length / 4);
-}
 function toTextForToolMessage(content) {
   if (Array.isArray(content)) {
     return summarizeToolContentForText(content);
@@ -1231,12 +1206,40 @@ function toTextForToolMessage(content) {
   }
   return String(content ?? "");
 }
+function filterCompacted(history) {
+  let summaryIndex = -1;
+  for (let i = history.length - 1; i >= 0; i--) {
+    const msg = history[i];
+    if (msg?.metadata?.isSummary === true) {
+      summaryIndex = i;
+      break;
+    }
+  }
+  if (summaryIndex === -1) {
+    return history.slice();
+  }
+  return history.slice(summaryIndex);
+}
+function formatToolOutputForDisplay(message) {
+  if ((0, import_types.isToolMessage)(message) && message.compactedAt) {
+    return "[Old tool result content cleared]";
+  }
+  if (typeof message.content === "string") {
+    return message.content;
+  }
+  if (Array.isArray(message.content)) {
+    return message.content.filter((part) => part.type === "text").map((part) => part.text).join("\n");
+  }
+  return "[no content]";
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  countMessagesTokens,
+  estimateMessagesTokens,
   expandBlobReferences,
   fileTypesToMimePatterns,
+  filterCompacted,
   filterMessagesByLLMCapabilities,
+  formatToolOutputForDisplay,
   getFileData,
   getFileDataWithBlobSupport,
   getFileMediaKind,