@dexto/core 1.1.4 → 1.1.6

package/dist/context/utils.js

@@ -0,0 +1,374 @@
+import { logger } from "../logger/index.js";
+import { validateModelFileSupport } from "../llm/registry.js";
+import { ContextError } from "./errors.js";
+import { safeStringify } from "../utils/safe-stringify.js";
+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;
+  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) {
+    logger.error(
+      `countMessagesTokens failed: ${error instanceof Error ? error.message : String(error)}`
+    );
+    throw 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();
+  }
+  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();
+  }
+  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 = 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) {
+    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);
+      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;
+        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)) {
+        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);
+        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: 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 safeStringify(cleaned);
+    }
+    return safeStringify(result ?? "");
+  } catch (err) {
+    logger.warn(`sanitizeToolResultToContent failed, falling back to string: ${String(err)}`);
+    try {
+      return 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 ?? "");
+}
+export {
+  countMessagesTokens,
+  filterMessagesByLLMCapabilities,
+  getFileData,
+  getImageData,
+  isLikelyBase64String,
+  parseDataUri,
+  sanitizeToolResultToContent,
+  summarizeToolContentForText,
+  toTextForToolMessage
+};

package/dist/errors/DextoBaseError.cjs

@@ -0,0 +1,36 @@
+"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 DextoBaseError_exports = {};
+__export(DextoBaseError_exports, {
+  DextoBaseError: () => DextoBaseError
+});
+module.exports = __toCommonJS(DextoBaseError_exports);
+var import_crypto = require("crypto");
+class DextoBaseError extends Error {
+  traceId;
+  constructor(message, traceId) {
+    super(message);
+    this.traceId = traceId || (0, import_crypto.randomUUID)();
+    this.name = this.constructor.name;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DextoBaseError
+});

package/dist/errors/DextoBaseError.d.cts

@@ -0,0 +1,15 @@
+/**
+ * Abstract base class for all Dexto errors
+ * Provides common functionality like trace ID generation and JSON serialization
+ */
+declare abstract class DextoBaseError extends Error {
+    readonly traceId: string;
+    constructor(message: string, traceId?: string);
+    /**
+     * Convert error to JSON representation
+     * Must be implemented by subclasses
+     */
+    abstract toJSON(): Record<string, any>;
+}
+
+export { DextoBaseError };

package/dist/errors/DextoBaseError.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Abstract base class for all Dexto errors
+ * Provides common functionality like trace ID generation and JSON serialization
+ */
+declare abstract class DextoBaseError extends Error {
+    readonly traceId: string;
+    constructor(message: string, traceId?: string);
+    /**
+     * Convert error to JSON representation
+     * Must be implemented by subclasses
+     */
+    abstract toJSON(): Record<string, any>;
+}
+
+export { DextoBaseError };

package/dist/errors/DextoBaseError.js

@@ -0,0 +1,12 @@
+import { randomUUID } from "crypto";
+class DextoBaseError extends Error {
+  traceId;
+  constructor(message, traceId) {
+    super(message);
+    this.traceId = traceId || randomUUID();
+    this.name = this.constructor.name;
+  }
+}
+export {
+  DextoBaseError
+};

package/dist/errors/DextoRuntimeError.cjs

@@ -0,0 +1,50 @@
+"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 DextoRuntimeError_exports = {};
+__export(DextoRuntimeError_exports, {
+  DextoRuntimeError: () => DextoRuntimeError
+});
+module.exports = __toCommonJS(DextoRuntimeError_exports);
+var import_DextoBaseError = require("./DextoBaseError.js");
+class DextoRuntimeError extends import_DextoBaseError.DextoBaseError {
+  constructor(code, scope, type, message, context, recovery, traceId) {
+    super(message, traceId);
+    this.code = code;
+    this.scope = scope;
+    this.type = type;
+    this.context = context;
+    this.recovery = recovery;
+    this.name = "DextoRuntimeError";
+  }
+  toJSON() {
+    return {
+      code: this.code,
+      message: this.message,
+      scope: this.scope,
+      type: this.type,
+      context: this.context,
+      recovery: this.recovery,
+      traceId: this.traceId
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DextoRuntimeError
+});

package/dist/errors/DextoRuntimeError.d.cts

@@ -0,0 +1,37 @@
+import { DextoBaseError } from './DextoBaseError.cjs';
+import { DextoErrorCode, ErrorScope, ErrorType } from './types.cjs';
+import '../agent/error-codes.cjs';
+import '../config/error-codes.cjs';
+import '../context/error-codes.cjs';
+import '../llm/error-codes.cjs';
+import '../mcp/error-codes.cjs';
+import '../session/error-codes.cjs';
+import '../storage/error-codes.cjs';
+import '../systemPrompt/error-codes.cjs';
+import '../tools/error-codes.cjs';
+import '../preferences/error-codes.cjs';
+import '../agent/registry/error-codes.cjs';
+
+/**
+ * Runtime error class for single-issue errors
+ * Provides structured error information with scope, type, and recovery guidance
+ */
+declare class DextoRuntimeError<C = unknown> extends DextoBaseError {
+    readonly code: DextoErrorCode;
+    readonly scope: ErrorScope;
+    readonly type: ErrorType;
+    readonly context?: C | undefined;
+    readonly recovery?: string | string[] | undefined;
+    constructor(code: DextoErrorCode, scope: ErrorScope, type: ErrorType, message: string, context?: C | undefined, recovery?: string | string[] | undefined, traceId?: string);
+    toJSON(): {
+        code: DextoErrorCode;
+        message: string;
+        scope: ErrorScope;
+        type: ErrorType;
+        context: C | undefined;
+        recovery: string | string[] | undefined;
+        traceId: string;
+    };
+}
+
+export { DextoRuntimeError };

package/dist/errors/DextoRuntimeError.d.ts

@@ -0,0 +1,37 @@
+import { DextoBaseError } from './DextoBaseError.js';
+import { DextoErrorCode, ErrorScope, ErrorType } from './types.js';
+import '../agent/error-codes.js';
+import '../config/error-codes.js';
+import '../context/error-codes.js';
+import '../llm/error-codes.js';
+import '../mcp/error-codes.js';
+import '../session/error-codes.js';
+import '../storage/error-codes.js';
+import '../systemPrompt/error-codes.js';
+import '../tools/error-codes.js';
+import '../preferences/error-codes.js';
+import '../agent/registry/error-codes.js';
+
+/**
+ * Runtime error class for single-issue errors
+ * Provides structured error information with scope, type, and recovery guidance
+ */
+declare class DextoRuntimeError<C = unknown> extends DextoBaseError {
+    readonly code: DextoErrorCode;
+    readonly scope: ErrorScope;
+    readonly type: ErrorType;
+    readonly context?: C | undefined;
+    readonly recovery?: string | string[] | undefined;
+    constructor(code: DextoErrorCode, scope: ErrorScope, type: ErrorType, message: string, context?: C | undefined, recovery?: string | string[] | undefined, traceId?: string);
+    toJSON(): {
+        code: DextoErrorCode;
+        message: string;
+        scope: ErrorScope;
+        type: ErrorType;
+        context: C | undefined;
+        recovery: string | string[] | undefined;
+        traceId: string;
+    };
+}
+
+export { DextoRuntimeError };

package/dist/errors/DextoRuntimeError.js

@@ -0,0 +1,26 @@
+import { DextoBaseError } from "./DextoBaseError.js";
+class DextoRuntimeError extends DextoBaseError {
+  constructor(code, scope, type, message, context, recovery, traceId) {
+    super(message, traceId);
+    this.code = code;
+    this.scope = scope;
+    this.type = type;
+    this.context = context;
+    this.recovery = recovery;
+    this.name = "DextoRuntimeError";
+  }
+  toJSON() {
+    return {
+      code: this.code,
+      message: this.message,
+      scope: this.scope,
+      type: this.type,
+      context: this.context,
+      recovery: this.recovery,
+      traceId: this.traceId
+    };
+  }
+}
+export {
+  DextoRuntimeError
+};