@dexto/core 1.1.4 → 1.1.6

package/dist/context/types.d.ts

@@ -0,0 +1,113 @@
+import { LLMProvider, LLMRouter } from '../llm/types.js';
+
+/**
+ * Internal representation of a message in a conversation.
+ * Standardizes message format across different LLM providers.
+ */
+interface ImageData {
+    image: string | Uint8Array | Buffer | ArrayBuffer | URL;
+    mimeType?: string;
+}
+interface FileData {
+    data: string | Uint8Array | Buffer | ArrayBuffer | URL;
+    mimeType: string;
+    filename?: string;
+}
+interface TextPart {
+    type: 'text';
+    text: string;
+}
+interface ImagePart extends ImageData {
+    type: 'image';
+}
+interface FilePart extends FileData {
+    type: 'file';
+}
+interface InternalMessage {
+    /**
+     * The role of the entity sending the message.
+     * - 'system': System instructions or context
+     * - 'user': End-user input
+     * - 'assistant': LLM response
+     * - 'tool': Result from a tool execution
+     */
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    /**
+     * Timestamp when the message was created (Unix timestamp in milliseconds).
+     * TODO: Populate this field when messages are created. Currently not implemented.
+     * @see https://github.com/truffle-ai/dexto/issues/XXX
+     */
+    timestamp?: number;
+    /**
+     * The content of the message.
+     * - String for system, assistant (text only), and tool messages.
+     * - Array of parts for user messages (can include text, images, and files).
+     * - null if an assistant message only contains tool calls.
+     */
+    content: string | null | Array<TextPart | ImagePart | FilePart>;
+    /**
+     * Optional model reasoning text associated with an assistant response.
+     * Present when the provider supports reasoning and returns a final reasoning trace.
+     */
+    reasoning?: string;
+    /**
+     * Optional token usage accounting for this assistant response.
+     */
+    tokenUsage?: {
+        inputTokens?: number;
+        outputTokens?: number;
+        reasoningTokens?: number;
+        totalTokens?: number;
+    };
+    /**
+     * Optional model identifier for assistant messages.
+     * Indicates which LLM model generated this response.
+     */
+    model?: string;
+    /** Optional provider identifier for assistant messages. */
+    provider?: LLMProvider;
+    /**
+     * Optional router metadata for assistant messages.
+     * Indicates which router was used to route the request.
+     */
+    router?: LLMRouter;
+    /**
+     * Tool calls made by the assistant.
+     * Only present in assistant messages when the LLM requests tool execution.
+     */
+    toolCalls?: Array<{
+        /**
+         * Unique identifier for this tool call
+         */
+        id: string;
+        /**
+         * The type of tool call (currently only 'function' is supported)
+         */
+        type: 'function';
+        /**
+         * Function call details
+         */
+        function: {
+            /**
+             * Name of the function to call
+             */
+            name: string;
+            /**
+             * Arguments for the function in JSON string format
+             */
+            arguments: string;
+        };
+    }>;
+    /**
+     * ID of the tool call this message is responding to.
+     * Only present in tool messages.
+     */
+    toolCallId?: string;
+    /**
+     * Name of the tool that produced this result.
+     * Only present in tool messages.
+     */
+    name?: string;
+}
+
+export type { FileData, FilePart, ImageData, ImagePart, InternalMessage, TextPart };

package/dist/context/utils.cjs

@@ -0,0 +1,406 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+__export(utils_exports, {
+  countMessagesTokens: () => countMessagesTokens,
+  filterMessagesByLLMCapabilities: () => filterMessagesByLLMCapabilities,
+  getFileData: () => getFileData,
+  getImageData: () => getImageData,
+  isLikelyBase64String: () => isLikelyBase64String,
+  parseDataUri: () => parseDataUri,
+  sanitizeToolResultToContent: () => sanitizeToolResultToContent,
+  summarizeToolContentForText: () => summarizeToolContentForText,
+  toTextForToolMessage: () => toTextForToolMessage
+});
+module.exports = __toCommonJS(utils_exports);
+var import_logger = require("../logger/index.cjs");
+var import_registry = require("../llm/registry.cjs");
+var import_errors = require("./errors.js");
+var import_safe_stringify = require("../utils/safe-stringify.cjs");
+const DEFAULT_OVERHEAD_PER_MESSAGE = 4;
+const MIN_BASE64_HEURISTIC_LENGTH = 512;
+const MAX_TOOL_TEXT_CHARS = 8e3;
+function countMessagesTokens(history, tokenizer, overheadPerMessage = DEFAULT_OVERHEAD_PER_MESSAGE) {
+  let total = 0;
+  import_logger.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;
+    }
+  } catch (error) {
+    import_logger.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;
+}
+function getImageData(imagePart) {
+  const { image } = imagePart;
+  if (typeof image === "string") {
+    return image;
+  } else if (image instanceof Buffer) {
+    return image.toString("base64");
+  } else if (image instanceof Uint8Array) {
+    return Buffer.from(image).toString("base64");
+  } else if (image instanceof ArrayBuffer) {
+    return Buffer.from(new Uint8Array(image)).toString("base64");
+  } else if (image instanceof URL) {
+    return image.toString();
+  }
+  import_logger.logger.warn(`Unexpected image data type in getImageData: ${typeof image}`);
+  return "";
+}
+function getFileData(filePart) {
+  const { data } = filePart;
+  if (typeof data === "string") {
+    return data;
+  } else if (data instanceof Buffer) {
+    return data.toString("base64");
+  } else if (data instanceof Uint8Array) {
+    return Buffer.from(data).toString("base64");
+  } else if (data instanceof ArrayBuffer) {
+    return Buffer.from(new Uint8Array(data)).toString("base64");
+  } else if (data instanceof URL) {
+    return data.toString();
+  }
+  import_logger.logger.warn(`Unexpected file data type in getFileData: ${typeof data}`);
+  return "";
+}
+function filterMessagesByLLMCapabilities(messages, config) {
+  try {
+    return messages.map((message) => {
+      if (message.role !== "user" || !Array.isArray(message.content)) {
+        return message;
+      }
+      const filteredContent = message.content.filter((part) => {
+        if (part.type === "text" || part.type === "image") {
+          return true;
+        }
+        if (part.type === "file" && part.mimeType) {
+          const validation = (0, import_registry.validateModelFileSupport)(
+            config.provider,
+            config.model,
+            part.mimeType
+          );
+          return validation.isSupported;
+        }
+        return true;
+      });
+      if (filteredContent.length === 0) {
+        filteredContent.push({
+          type: "text",
+          text: `[File attachment removed - not supported by ${config.model}]`
+        });
+      }
+      return {
+        ...message,
+        content: filteredContent
+      };
+    });
+  } catch (error) {
+    import_logger.logger.warn(`Failed to filter messages by LLM capabilities: ${String(error)}`);
+    return messages;
+  }
+}
+function isLikelyBase64String(value, minLength = MIN_BASE64_HEURISTIC_LENGTH) {
+  if (!value || value.length < minLength) return false;
+  if (value.startsWith("data:") && value.includes(";base64,")) return true;
+  const b64Regex = /^[A-Za-z0-9+/=\r\n]+$/;
+  if (!b64Regex.test(value)) return false;
+  const nonWordRatio = (value.match(/[^A-Za-z0-9+/=]/g)?.length || 0) / value.length;
+  return nonWordRatio < 0.01;
+}
+function parseDataUri(value) {
+  if (!value.startsWith("data:")) return null;
+  const commaIdx = value.indexOf(",");
+  if (commaIdx === -1) return null;
+  const meta = value.slice(5, commaIdx);
+  if (!/;base64$/i.test(meta)) return null;
+  const mediaType = meta.replace(/;base64$/i, "") || "application/octet-stream";
+  const base64 = value.slice(commaIdx + 1);
+  return { mediaType, base64 };
+}
+function sanitizeDeepObject(obj) {
+  if (obj == null) return obj;
+  if (typeof obj === "string") {
+    if (isLikelyBase64String(obj)) {
+      const approxBytes = Math.floor(obj.length * 3 / 4);
+      import_logger.logger.debug(
+        `sanitizeDeepObject: replaced large base64 string (~${approxBytes} bytes) with placeholder`
+      );
+      return `[binary data omitted ~${approxBytes} bytes]`;
+    }
+    return obj;
+  }
+  if (Array.isArray(obj)) return obj.map((x) => sanitizeDeepObject(x));
+  if (typeof obj === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(obj)) {
+      out[k] = sanitizeDeepObject(v);
+    }
+    return out;
+  }
+  return obj;
+}
+function sanitizeToolResultToContent(result) {
+  try {
+    if (typeof result === "string") {
+      const dataUri = parseDataUri(result);
+      if (dataUri) {
+        const mediaType = dataUri.mediaType;
+        import_logger.logger.debug(
+          `sanitizeToolResultToContent: detected data URI (${mediaType}), converting to media part`
+        );
+        if (mediaType.startsWith("image/")) {
+          return [{ type: "image", image: dataUri.base64, mimeType: mediaType }];
+        }
+        return [{ type: "file", data: dataUri.base64, mimeType: mediaType }];
+      }
+      if (isLikelyBase64String(result)) {
+        import_logger.logger.debug(
+          "sanitizeToolResultToContent: detected base64-like string, converting to file part"
+        );
+        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);
+        import_logger.logger.debug(
+          `sanitizeToolResultToContent: truncating long text tool output (len=${result.length})`
+        );
+        return `${head}
+... [${result.length - 5e3} chars omitted] ...
+${tail}`;
+      }
+      return result;
+    }
+    if (Array.isArray(result)) {
+      const parts = [];
+      for (const item of result) {
+        if (item == null) continue;
+        if (typeof item === "string") {
+          const dataUri = parseDataUri(item);
+          if (dataUri) {
+            const mt = dataUri.mediaType;
+            if (mt.startsWith("image/"))
+              parts.push({ type: "image", image: dataUri.base64, mimeType: mt });
+            else parts.push({ type: "file", data: dataUri.base64, mimeType: mt });
+            continue;
+          }
+          if (isLikelyBase64String(item)) {
+            parts.push({
+              type: "file",
+              data: item,
+              mimeType: "application/octet-stream",
+              filename: "tool-output.bin"
+            });
+            continue;
+          }
+          parts.push({ type: "text", text: item });
+          continue;
+        }
+        if (typeof item === "object") {
+          const obj = item;
+          if (obj.type === "text" && typeof obj.text === "string") {
+            parts.push({ type: "text", text: obj.text });
+            continue;
+          }
+          if (obj.type === "image" && obj.image !== void 0 || "image" in obj) {
+            parts.push({
+              type: "image",
+              image: getImageData({ image: obj.image }),
+              mimeType: obj.mimeType || "image/jpeg"
+            });
+            continue;
+          }
+          if (obj.type === "file" && obj.data !== void 0) {
+            parts.push({
+              type: "file",
+              data: getFileData({ data: obj.data }),
+              mimeType: obj.mimeType || "application/octet-stream",
+              filename: obj.filename
+            });
+            continue;
+          }
+          if ("data" in obj && (typeof obj.mimeType === "string" || obj.filename)) {
+            parts.push({
+              type: "file",
+              data: getFileData({ data: obj.data }),
+              mimeType: obj.mimeType || "application/octet-stream",
+              filename: obj.filename
+            });
+            continue;
+          }
+          const cleaned = sanitizeDeepObject(obj);
+          parts.push({ type: "text", text: (0, import_safe_stringify.safeStringify)(cleaned) });
+          continue;
+        }
+        parts.push({ type: "text", text: String(item) });
+      }
+      return parts;
+    }
+    if (result && typeof result === "object") {
+      const anyObj = result;
+      if ("image" in anyObj) {
+        return [
+          {
+            type: "image",
+            image: getImageData({ image: anyObj.image }),
+            mimeType: anyObj.mimeType || "image/jpeg"
+          }
+        ];
+      }
+      if ("data" in anyObj && anyObj.mimeType) {
+        return [
+          {
+            type: "file",
+            data: getFileData({ data: anyObj.data }),
+            mimeType: anyObj.mimeType,
+            filename: anyObj.filename
+          }
+        ];
+      }
+      const cleaned = sanitizeDeepObject(anyObj);
+      return (0, import_safe_stringify.safeStringify)(cleaned);
+    }
+    return (0, import_safe_stringify.safeStringify)(result ?? "");
+  } catch (err) {
+    import_logger.logger.warn(`sanitizeToolResultToContent failed, falling back to string: ${String(err)}`);
+    try {
+      return (0, import_safe_stringify.safeStringify)(result ?? "");
+    } catch {
+      return String(result ?? "");
+    }
+  }
+}
+function summarizeToolContentForText(content) {
+  if (!Array.isArray(content)) return String(content || "");
+  const parts = [];
+  for (const p of content) {
+    if (p.type === "text") {
+      parts.push(p.text);
+    } else if (p.type === "image") {
+      let bytes = 0;
+      if (typeof p.image === "string") bytes = Math.floor(p.image.length * 3 / 4);
+      else if (p.image instanceof ArrayBuffer) bytes = p.image.byteLength;
+      else if (p.image instanceof Uint8Array) bytes = p.image.length;
+      else if (p.image instanceof Buffer) bytes = p.image.length;
+      parts.push(`[image ${p.mimeType || "image"} ~${Math.ceil(bytes / 1024)}KB]`);
+    } else if (p.type === "file") {
+      let bytes = 0;
+      if (typeof p.data === "string") bytes = Math.floor(p.data.length * 3 / 4);
+      else if (p.data instanceof ArrayBuffer) bytes = p.data.byteLength;
+      else if (p.data instanceof Uint8Array) bytes = p.data.length;
+      else if (p.data instanceof Buffer) bytes = p.data.length;
+      const label = p.filename ? `${p.filename}` : `${p.mimeType || "file"}`;
+      parts.push(`[file ${label} ~${Math.ceil(bytes / 1024)}KB]`);
+    }
+  }
+  const summary = parts.join("\n");
+  return summary.slice(0, 4e3);
+}
+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);
+  }
+  if (typeof content === "string") {
+    return isLikelyBase64String(content) ? "[binary data omitted]" : content;
+  }
+  return String(content ?? "");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  countMessagesTokens,
+  filterMessagesByLLMCapabilities,
+  getFileData,
+  getImageData,
+  isLikelyBase64String,
+  parseDataUri,
+  sanitizeToolResultToContent,
+  summarizeToolContentForText,
+  toTextForToolMessage
+});

package/dist/context/utils.d.cts

@@ -0,0 +1,79 @@
+import { InternalMessage } from './types.cjs';
+import { ITokenizer } from '../llm/tokenizer/types.cjs';
+import { LLMContext } from '../llm/types.cjs';
+
+/**
+ * Counts the total tokens in an array of InternalMessages using a provided tokenizer.
+ * Includes an estimated overhead per message.
+ *
+ * NOTE: This function counts tokens on the raw InternalMessage history and has limitations:
+ * 1. It does not account for provider-specific formatting (uses raw content).
+ * 2. It ignores the token cost of images and files in multimodal messages (counts text only).
+ * 3. The overhead is a fixed approximation.
+ * For more accurate counting reflecting the final provider payload, use ContextManager.countTotalTokens().
+ *
+ * @param history The array of messages to count.
+ * @param tokenizer The tokenizer instance to use for counting.
+ * @param overheadPerMessage Optional overhead tokens per message. Defaults to 4.
+ * @returns The total token count.
+ * @throws Error if token counting fails within the tokenizer.
+ */
+declare function countMessagesTokens(history: InternalMessage[], tokenizer: ITokenizer, overheadPerMessage?: number): number;
+/**
+ * Extracts image data (base64 or URL) from an ImagePart or raw buffer.
+ * @param imagePart The image part containing image data
+ * @returns Base64-encoded string or URL string
+ */
+declare function getImageData(imagePart: {
+    image: string | Uint8Array | Buffer | ArrayBuffer | URL;
+}): string;
+/**
+ * Extracts file data (base64 or URL) from a FilePart or raw buffer.
+ * @param filePart The file part containing file data
+ * @returns Base64-encoded string or URL string
+ */
+declare function getFileData(filePart: {
+    data: string | Uint8Array | Buffer | ArrayBuffer | URL;
+}): string;
+/**
+ * Filters message content based on LLM capabilities.
+ * Removes unsupported file attachments while preserving supported content.
+ * Uses model-specific validation when available, falls back to provider-level.
+ * @param messages Array of internal messages to filter
+ * @param config The LLM configuration (provider and optional model)
+ * @returns Filtered messages with unsupported content removed
+ */
+declare function filterMessagesByLLMCapabilities(messages: InternalMessage[], config: LLMContext): InternalMessage[];
+/**
+ * Detect if a string is likely a Base64 blob (not a typical sentence/text).
+ * Uses a length threshold and character set heuristic.
+ */
+declare function isLikelyBase64String(value: string, minLength?: number): boolean;
+/**
+ * Parse data URI and return { mediaType, base64 } or null if not a data URI.
+ */
+declare function parseDataUri(value: string): {
+    mediaType: string;
+    base64: string;
+} | null;
+/**
+ * Convert an arbitrary tool result into safe InternalMessage content.
+ * - Converts data URIs and base64 blobs to media/file parts
+ * - Removes huge binary blobs inside objects
+ * - Truncates extremely long raw text
+ */
+declare function sanitizeToolResultToContent(result: unknown): InternalMessage['content'];
+/**
+ * Produce a short textual summary for tool content, to be used with providers
+ * that only accept text for tool messages (e.g., OpenAI/Anthropic tool role).
+ */
+declare function summarizeToolContentForText(content: InternalMessage['content']): string;
+/**
+ * Convert arbitrary tool content to safe text for providers that only accept textual tool messages.
+ * - If content is an array of parts, summarize it.
+ * - If content is a string that looks like base64/data URI, replace with a short placeholder.
+ * - Otherwise pass text through.
+ */
+declare function toTextForToolMessage(content: InternalMessage['content']): string;
+
+export { countMessagesTokens, filterMessagesByLLMCapabilities, getFileData, getImageData, isLikelyBase64String, parseDataUri, sanitizeToolResultToContent, summarizeToolContentForText, toTextForToolMessage };

package/dist/context/utils.d.ts

@@ -0,0 +1,79 @@
+import { InternalMessage } from './types.js';
+import { ITokenizer } from '../llm/tokenizer/types.js';
+import { LLMContext } from '../llm/types.js';
+
+/**
+ * Counts the total tokens in an array of InternalMessages using a provided tokenizer.
+ * Includes an estimated overhead per message.
+ *
+ * NOTE: This function counts tokens on the raw InternalMessage history and has limitations:
+ * 1. It does not account for provider-specific formatting (uses raw content).
+ * 2. It ignores the token cost of images and files in multimodal messages (counts text only).
+ * 3. The overhead is a fixed approximation.
+ * For more accurate counting reflecting the final provider payload, use ContextManager.countTotalTokens().
+ *
+ * @param history The array of messages to count.
+ * @param tokenizer The tokenizer instance to use for counting.
+ * @param overheadPerMessage Optional overhead tokens per message. Defaults to 4.
+ * @returns The total token count.
+ * @throws Error if token counting fails within the tokenizer.
+ */
+declare function countMessagesTokens(history: InternalMessage[], tokenizer: ITokenizer, overheadPerMessage?: number): number;
+/**
+ * Extracts image data (base64 or URL) from an ImagePart or raw buffer.
+ * @param imagePart The image part containing image data
+ * @returns Base64-encoded string or URL string
+ */
+declare function getImageData(imagePart: {
+    image: string | Uint8Array | Buffer | ArrayBuffer | URL;
+}): string;
+/**
+ * Extracts file data (base64 or URL) from a FilePart or raw buffer.
+ * @param filePart The file part containing file data
+ * @returns Base64-encoded string or URL string
+ */
+declare function getFileData(filePart: {
+    data: string | Uint8Array | Buffer | ArrayBuffer | URL;
+}): string;
+/**
+ * Filters message content based on LLM capabilities.
+ * Removes unsupported file attachments while preserving supported content.
+ * Uses model-specific validation when available, falls back to provider-level.
+ * @param messages Array of internal messages to filter
+ * @param config The LLM configuration (provider and optional model)
+ * @returns Filtered messages with unsupported content removed
+ */
+declare function filterMessagesByLLMCapabilities(messages: InternalMessage[], config: LLMContext): InternalMessage[];
+/**
+ * Detect if a string is likely a Base64 blob (not a typical sentence/text).
+ * Uses a length threshold and character set heuristic.
+ */
+declare function isLikelyBase64String(value: string, minLength?: number): boolean;
+/**
+ * Parse data URI and return { mediaType, base64 } or null if not a data URI.
+ */
+declare function parseDataUri(value: string): {
+    mediaType: string;
+    base64: string;
+} | null;
+/**
+ * Convert an arbitrary tool result into safe InternalMessage content.
+ * - Converts data URIs and base64 blobs to media/file parts
+ * - Removes huge binary blobs inside objects
+ * - Truncates extremely long raw text
+ */
+declare function sanitizeToolResultToContent(result: unknown): InternalMessage['content'];
+/**
+ * Produce a short textual summary for tool content, to be used with providers
+ * that only accept text for tool messages (e.g., OpenAI/Anthropic tool role).
+ */
+declare function summarizeToolContentForText(content: InternalMessage['content']): string;
+/**
+ * Convert arbitrary tool content to safe text for providers that only accept textual tool messages.
+ * - If content is an array of parts, summarize it.
+ * - If content is a string that looks like base64/data URI, replace with a short placeholder.
+ * - Otherwise pass text through.
+ */
+declare function toTextForToolMessage(content: InternalMessage['content']): string;
+
+export { countMessagesTokens, filterMessagesByLLMCapabilities, getFileData, getImageData, isLikelyBase64String, parseDataUri, sanitizeToolResultToContent, summarizeToolContentForText, toTextForToolMessage };