@dexto/core 1.1.4 → 1.1.6

package/dist/llm/types.d.ts

@@ -0,0 +1,29 @@
+declare const LLM_PROVIDERS: readonly ["openai", "openai-compatible", "anthropic", "google", "groq", "xai", "cohere"];
+type LLMProvider = (typeof LLM_PROVIDERS)[number];
+declare const LLM_ROUTERS: readonly ["vercel", "in-built"];
+type LLMRouter = (typeof LLM_ROUTERS)[number];
+declare const SUPPORTED_FILE_TYPES: readonly ["pdf", "image", "audio"];
+type SupportedFileType = (typeof SUPPORTED_FILE_TYPES)[number];
+/**
+ * LLMRouter defines the routing backend for LLM service instantiation.
+ * 'vercel' = use Vercel LLM service, 'in-built' = use in-built LLM service
+ * This type is now defined in the registry as the source of truth.
+ */
+/**
+ * Context interface for message formatters.
+ * Provides runtime information for model-aware processing.
+ */
+interface LLMContext {
+    /** LLM provider name (e.g., 'google.generative-ai', 'openai') */
+    provider: LLMProvider;
+    /** Specific LLM model name (e.g., 'gemini-2.5-flash', 'gpt-4') */
+    model: string;
+}
+interface LLMUpdateContext {
+    provider?: LLMProvider;
+    model?: string;
+    router?: LLMRouter;
+    suggestedAction?: string;
+}
+
+export { type LLMContext, type LLMProvider, type LLMRouter, type LLMUpdateContext, LLM_PROVIDERS, LLM_ROUTERS, SUPPORTED_FILE_TYPES, type SupportedFileType };

package/dist/llm/types.js

@@ -0,0 +1,16 @@
+const LLM_PROVIDERS = [
+  "openai",
+  "openai-compatible",
+  "anthropic",
+  "google",
+  "groq",
+  "xai",
+  "cohere"
+];
+const LLM_ROUTERS = ["vercel", "in-built"];
+const SUPPORTED_FILE_TYPES = ["pdf", "image", "audio"];
+export {
+  LLM_PROVIDERS,
+  LLM_ROUTERS,
+  SUPPORTED_FILE_TYPES
+};

package/dist/llm/validation.cjs

@@ -0,0 +1,162 @@
+"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 validation_exports = {};
+__export(validation_exports, {
+  validateInputForLLM: () => validateInputForLLM
+});
+module.exports = __toCommonJS(validation_exports);
+var import_registry = require("./registry.js");
+var import_logger = require("../logger/index.js");
+var import_result = require("../utils/result.js");
+var import_types = require("../errors/types.cjs");
+var import_error_codes = require("./error-codes.js");
+const MAX_FILE_SIZE = 67108864;
+const MAX_IMAGE_SIZE = 20971520;
+function validateInputForLLM(input, config) {
+  const issues = [];
+  const validationData = {};
+  try {
+    const context = {
+      provider: config.provider,
+      model: config.model
+    };
+    if (input.fileData) {
+      const fileValidation = validateFileInput(input.fileData, config);
+      validationData.fileValidation = fileValidation;
+      if (!fileValidation.isSupported) {
+        issues.push({
+          code: import_error_codes.LLMErrorCode.INPUT_FILE_UNSUPPORTED,
+          message: fileValidation.error || "File type not supported by current LLM",
+          scope: import_types.ErrorScope.LLM,
+          type: import_types.ErrorType.USER,
+          severity: "error",
+          context: {
+            ...context,
+            fileType: fileValidation.fileType,
+            mimeType: input.fileData.mimeType,
+            filename: input.fileData.filename,
+            suggestedAction: "Use a supported file type or different model"
+          }
+        });
+      }
+    }
+    if (input.imageData) {
+      const imageValidation = validateImageInput(input.imageData, config);
+      validationData.imageValidation = imageValidation;
+      if (!imageValidation.isSupported) {
+        issues.push({
+          code: import_error_codes.LLMErrorCode.INPUT_IMAGE_UNSUPPORTED,
+          message: imageValidation.error || "Image format not supported by current LLM",
+          scope: import_types.ErrorScope.LLM,
+          type: import_types.ErrorType.USER,
+          severity: "error",
+          context: {
+            ...context,
+            suggestedAction: "Use a supported image format or different model"
+          }
+        });
+      }
+    }
+    return issues.length === 0 ? (0, import_result.ok)(validationData, issues) : (0, import_result.fail)(issues);
+  } catch (error) {
+    import_logger.logger.error(`Error during input validation: ${error}`);
+    return (0, import_result.fail)([
+      {
+        code: import_error_codes.LLMErrorCode.REQUEST_INVALID_SCHEMA,
+        message: "Failed to validate input",
+        scope: import_types.ErrorScope.LLM,
+        type: import_types.ErrorType.SYSTEM,
+        severity: "error",
+        context: {
+          provider: config.provider,
+          model: config.model,
+          suggestedAction: "Check input format and try again"
+        }
+      }
+    ]);
+  }
+}
+function validateFileInput(fileData, config) {
+  import_logger.logger.info(`Validating file input: ${fileData.mimeType}`);
+  if (typeof fileData.data === "string" && fileData.data.length > MAX_FILE_SIZE) {
+    return {
+      isSupported: false,
+      error: "File size too large (max 64MB)"
+    };
+  }
+  const baseMimeType = fileData.mimeType.toLowerCase().split(";")[0]?.trim() || fileData.mimeType.toLowerCase();
+  const allowedMimeTypes = (0, import_registry.getAllowedMimeTypes)();
+  if (!allowedMimeTypes.includes(baseMimeType)) {
+    return {
+      isSupported: false,
+      error: `Unsupported file type: ${fileData.mimeType}`
+    };
+  }
+  if (typeof fileData.data === "string") {
+    const base64Regex = /^[A-Za-z0-9+/]+={0,2}$/;
+    if (!base64Regex.test(fileData.data) || fileData.data.length % 4 !== 0) {
+      return {
+        isSupported: false,
+        error: "Invalid file data format"
+      };
+    }
+  }
+  if (config.model) {
+    return (0, import_registry.validateModelFileSupport)(config.provider, config.model, fileData.mimeType);
+  }
+  return {
+    isSupported: false,
+    error: "Model must be specified for file capability validation"
+  };
+}
+function validateImageInput(imageData, config) {
+  import_logger.logger.info(`Validating image input: ${imageData.mimeType}`);
+  if (typeof imageData.image === "string" && imageData.image.length > MAX_IMAGE_SIZE) {
+    return {
+      isSupported: false,
+      error: `Image size too large (max ${MAX_IMAGE_SIZE / 1048576}MB)`
+    };
+  }
+  let resolvedMime = imageData.mimeType?.toLowerCase();
+  if (!resolvedMime && typeof imageData.image === "string") {
+    const dataUrlMatch = /^data:([^;]+);base64,/i.exec(imageData.image);
+    if (dataUrlMatch && dataUrlMatch[1]) {
+      resolvedMime = dataUrlMatch[1].toLowerCase();
+    }
+  }
+  if (!resolvedMime) {
+    return { isSupported: false, error: "Missing image MIME type" };
+  }
+  if (!config.model) {
+    return {
+      isSupported: false,
+      error: "Model must be specified for image capability validation"
+    };
+  }
+  const baseMimeType = resolvedMime.split(";")[0]?.trim() || resolvedMime;
+  const res = (0, import_registry.validateModelFileSupport)(config.provider, config.model, baseMimeType);
+  return {
+    isSupported: res.isSupported,
+    ...res.error ? { error: res.error } : {}
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  validateInputForLLM
+});

package/dist/llm/validation.d.cts

@@ -0,0 +1,60 @@
+import { LLMProvider } from './types.cjs';
+import { ImageData, FileData } from '../context/types.cjs';
+import { Result } from '../utils/result.cjs';
+import 'zod';
+import '../errors/types.cjs';
+import '../agent/error-codes.cjs';
+import '../config/error-codes.cjs';
+import '../context/error-codes.cjs';
+import './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';
+
+interface ValidationLLMConfig {
+    provider: LLMProvider;
+    model?: string;
+}
+interface ValidationContext {
+    provider?: string;
+    model?: string | undefined;
+    fileSize?: number;
+    maxFileSize?: number;
+    filename?: string | undefined;
+    mimeType?: string;
+    fileType?: string | undefined;
+    suggestedAction?: string;
+}
+interface ValidationData {
+    fileValidation?: {
+        isSupported: boolean;
+        fileType?: string;
+        error?: string;
+    };
+    imageValidation?: {
+        isSupported: boolean;
+        error?: string;
+    };
+}
+/**
+ * Input interface for comprehensive validation
+ */
+interface ValidationInput {
+    text?: string;
+    imageData?: ImageData | undefined;
+    fileData?: FileData | undefined;
+}
+/**
+ * Validates all inputs (text, image, file) against LLM capabilities and security requirements.
+ * This is the single entry point for all input validation using pure Result<T,C> pattern.
+ * @param input The input data to validate (text, image, file)
+ * @param config The LLM configuration (provider and model)
+ * @returns Comprehensive validation result
+ */
+declare function validateInputForLLM(input: ValidationInput, config: ValidationLLMConfig): Result<ValidationData, ValidationContext>;
+
+export { type ValidationContext, type ValidationData, type ValidationInput, type ValidationLLMConfig, validateInputForLLM };

package/dist/llm/validation.d.ts

@@ -0,0 +1,60 @@
+import { LLMProvider } from './types.js';
+import { ImageData, FileData } from '../context/types.js';
+import { Result } from '../utils/result.js';
+import 'zod';
+import '../errors/types.js';
+import '../agent/error-codes.js';
+import '../config/error-codes.js';
+import '../context/error-codes.js';
+import './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';
+
+interface ValidationLLMConfig {
+    provider: LLMProvider;
+    model?: string;
+}
+interface ValidationContext {
+    provider?: string;
+    model?: string | undefined;
+    fileSize?: number;
+    maxFileSize?: number;
+    filename?: string | undefined;
+    mimeType?: string;
+    fileType?: string | undefined;
+    suggestedAction?: string;
+}
+interface ValidationData {
+    fileValidation?: {
+        isSupported: boolean;
+        fileType?: string;
+        error?: string;
+    };
+    imageValidation?: {
+        isSupported: boolean;
+        error?: string;
+    };
+}
+/**
+ * Input interface for comprehensive validation
+ */
+interface ValidationInput {
+    text?: string;
+    imageData?: ImageData | undefined;
+    fileData?: FileData | undefined;
+}
+/**
+ * Validates all inputs (text, image, file) against LLM capabilities and security requirements.
+ * This is the single entry point for all input validation using pure Result<T,C> pattern.
+ * @param input The input data to validate (text, image, file)
+ * @param config The LLM configuration (provider and model)
+ * @returns Comprehensive validation result
+ */
+declare function validateInputForLLM(input: ValidationInput, config: ValidationLLMConfig): Result<ValidationData, ValidationContext>;
+
+export { type ValidationContext, type ValidationData, type ValidationInput, type ValidationLLMConfig, validateInputForLLM };

package/dist/llm/validation.js

@@ -0,0 +1,138 @@
+import { validateModelFileSupport, getAllowedMimeTypes } from "./registry.js";
+import { logger } from "../logger/index.js";
+import { ok, fail } from "../utils/result.js";
+import { ErrorScope, ErrorType } from "../errors/types.js";
+import { LLMErrorCode } from "./error-codes.js";
+const MAX_FILE_SIZE = 67108864;
+const MAX_IMAGE_SIZE = 20971520;
+function validateInputForLLM(input, config) {
+  const issues = [];
+  const validationData = {};
+  try {
+    const context = {
+      provider: config.provider,
+      model: config.model
+    };
+    if (input.fileData) {
+      const fileValidation = validateFileInput(input.fileData, config);
+      validationData.fileValidation = fileValidation;
+      if (!fileValidation.isSupported) {
+        issues.push({
+          code: LLMErrorCode.INPUT_FILE_UNSUPPORTED,
+          message: fileValidation.error || "File type not supported by current LLM",
+          scope: ErrorScope.LLM,
+          type: ErrorType.USER,
+          severity: "error",
+          context: {
+            ...context,
+            fileType: fileValidation.fileType,
+            mimeType: input.fileData.mimeType,
+            filename: input.fileData.filename,
+            suggestedAction: "Use a supported file type or different model"
+          }
+        });
+      }
+    }
+    if (input.imageData) {
+      const imageValidation = validateImageInput(input.imageData, config);
+      validationData.imageValidation = imageValidation;
+      if (!imageValidation.isSupported) {
+        issues.push({
+          code: LLMErrorCode.INPUT_IMAGE_UNSUPPORTED,
+          message: imageValidation.error || "Image format not supported by current LLM",
+          scope: ErrorScope.LLM,
+          type: ErrorType.USER,
+          severity: "error",
+          context: {
+            ...context,
+            suggestedAction: "Use a supported image format or different model"
+          }
+        });
+      }
+    }
+    return issues.length === 0 ? ok(validationData, issues) : fail(issues);
+  } catch (error) {
+    logger.error(`Error during input validation: ${error}`);
+    return fail([
+      {
+        code: LLMErrorCode.REQUEST_INVALID_SCHEMA,
+        message: "Failed to validate input",
+        scope: ErrorScope.LLM,
+        type: ErrorType.SYSTEM,
+        severity: "error",
+        context: {
+          provider: config.provider,
+          model: config.model,
+          suggestedAction: "Check input format and try again"
+        }
+      }
+    ]);
+  }
+}
+function validateFileInput(fileData, config) {
+  logger.info(`Validating file input: ${fileData.mimeType}`);
+  if (typeof fileData.data === "string" && fileData.data.length > MAX_FILE_SIZE) {
+    return {
+      isSupported: false,
+      error: "File size too large (max 64MB)"
+    };
+  }
+  const baseMimeType = fileData.mimeType.toLowerCase().split(";")[0]?.trim() || fileData.mimeType.toLowerCase();
+  const allowedMimeTypes = getAllowedMimeTypes();
+  if (!allowedMimeTypes.includes(baseMimeType)) {
+    return {
+      isSupported: false,
+      error: `Unsupported file type: ${fileData.mimeType}`
+    };
+  }
+  if (typeof fileData.data === "string") {
+    const base64Regex = /^[A-Za-z0-9+/]+={0,2}$/;
+    if (!base64Regex.test(fileData.data) || fileData.data.length % 4 !== 0) {
+      return {
+        isSupported: false,
+        error: "Invalid file data format"
+      };
+    }
+  }
+  if (config.model) {
+    return validateModelFileSupport(config.provider, config.model, fileData.mimeType);
+  }
+  return {
+    isSupported: false,
+    error: "Model must be specified for file capability validation"
+  };
+}
+function validateImageInput(imageData, config) {
+  logger.info(`Validating image input: ${imageData.mimeType}`);
+  if (typeof imageData.image === "string" && imageData.image.length > MAX_IMAGE_SIZE) {
+    return {
+      isSupported: false,
+      error: `Image size too large (max ${MAX_IMAGE_SIZE / 1048576}MB)`
+    };
+  }
+  let resolvedMime = imageData.mimeType?.toLowerCase();
+  if (!resolvedMime && typeof imageData.image === "string") {
+    const dataUrlMatch = /^data:([^;]+);base64,/i.exec(imageData.image);
+    if (dataUrlMatch && dataUrlMatch[1]) {
+      resolvedMime = dataUrlMatch[1].toLowerCase();
+    }
+  }
+  if (!resolvedMime) {
+    return { isSupported: false, error: "Missing image MIME type" };
+  }
+  if (!config.model) {
+    return {
+      isSupported: false,
+      error: "Model must be specified for image capability validation"
+    };
+  }
+  const baseMimeType = resolvedMime.split(";")[0]?.trim() || resolvedMime;
+  const res = validateModelFileSupport(config.provider, config.model, baseMimeType);
+  return {
+    isSupported: res.isSupported,
+    ...res.error ? { error: res.error } : {}
+  };
+}
+export {
+  validateInputForLLM
+};

package/dist/logger/browser.cjs

@@ -0,0 +1,86 @@
+"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 browser_exports = {};
+__export(browser_exports, {
+  Logger: () => Logger,
+  logger: () => logger
+});
+module.exports = __toCommonJS(browser_exports);
+class Logger {
+  level;
+  isSilent;
+  constructor(options = {}) {
+    this.level = (options.level || "info").toLowerCase();
+    this.isSilent = options.silent ?? false;
+  }
+  out(fn, args) {
+    if (!this.isSilent && typeof console !== "undefined") fn(...args);
+  }
+  error(message, meta) {
+    this.out(console.error, [message, meta]);
+  }
+  warn(message, meta) {
+    this.out(console.warn, [message, meta]);
+  }
+  info(message, meta) {
+    this.out(console.info, [message, meta]);
+  }
+  http(message, meta) {
+    this.out(console.info, [message, meta]);
+  }
+  verbose(message, meta) {
+    this.out(console.debug, [message, meta]);
+  }
+  debug(message, meta) {
+    this.out(console.debug, [message, meta]);
+  }
+  silly(message, meta) {
+    this.out(console.debug, [message, meta]);
+  }
+  displayAIResponse(response) {
+    this.out(console.log, [response]);
+  }
+  toolCall(toolName, args) {
+    this.out(console.log, ["Tool Call", toolName, args]);
+  }
+  toolResult(result) {
+    this.out(console.log, ["Tool Result", result]);
+  }
+  displayStartupInfo(info) {
+    this.out(console.log, ["Startup", info]);
+  }
+  displayError(message, error) {
+    this.out(console.error, [message, error]);
+  }
+  setLevel(level) {
+    this.level = level.toLowerCase();
+  }
+  getLevel() {
+    return this.level;
+  }
+  getLogFilePath() {
+    return null;
+  }
+}
+const logger = new Logger();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Logger,
+  logger
+});

package/dist/logger/browser.d.cts

@@ -0,0 +1,29 @@
+interface LoggerOptions {
+    level?: string;
+    silent?: boolean;
+    logToConsole?: boolean;
+}
+declare class Logger {
+    private level;
+    private isSilent;
+    constructor(options?: LoggerOptions);
+    private out;
+    error(message: any, meta?: any): void;
+    warn(message: any, meta?: any): void;
+    info(message: any, meta?: any): void;
+    http(message: any, meta?: any): void;
+    verbose(message: any, meta?: any): void;
+    debug(message: any, meta?: any): void;
+    silly(message: any, meta?: any): void;
+    displayAIResponse(response: any): void;
+    toolCall(toolName: string, args: any): void;
+    toolResult(result: any): void;
+    displayStartupInfo(info: Record<string, any>): void;
+    displayError(message: string, error?: Error): void;
+    setLevel(level: string): void;
+    getLevel(): string;
+    getLogFilePath(): string | null;
+}
+declare const logger: Logger;
+
+export { Logger, type LoggerOptions, logger };

package/dist/logger/browser.d.ts

@@ -0,0 +1,29 @@
+interface LoggerOptions {
+    level?: string;
+    silent?: boolean;
+    logToConsole?: boolean;
+}
+declare class Logger {
+    private level;
+    private isSilent;
+    constructor(options?: LoggerOptions);
+    private out;
+    error(message: any, meta?: any): void;
+    warn(message: any, meta?: any): void;
+    info(message: any, meta?: any): void;
+    http(message: any, meta?: any): void;
+    verbose(message: any, meta?: any): void;
+    debug(message: any, meta?: any): void;
+    silly(message: any, meta?: any): void;
+    displayAIResponse(response: any): void;
+    toolCall(toolName: string, args: any): void;
+    toolResult(result: any): void;
+    displayStartupInfo(info: Record<string, any>): void;
+    displayError(message: string, error?: Error): void;
+    setLevel(level: string): void;
+    getLevel(): string;
+    getLogFilePath(): string | null;
+}
+declare const logger: Logger;
+
+export { Logger, type LoggerOptions, logger };

package/dist/logger/browser.js

@@ -0,0 +1,61 @@
+class Logger {
+  level;
+  isSilent;
+  constructor(options = {}) {
+    this.level = (options.level || "info").toLowerCase();
+    this.isSilent = options.silent ?? false;
+  }
+  out(fn, args) {
+    if (!this.isSilent && typeof console !== "undefined") fn(...args);
+  }
+  error(message, meta) {
+    this.out(console.error, [message, meta]);
+  }
+  warn(message, meta) {
+    this.out(console.warn, [message, meta]);
+  }
+  info(message, meta) {
+    this.out(console.info, [message, meta]);
+  }
+  http(message, meta) {
+    this.out(console.info, [message, meta]);
+  }
+  verbose(message, meta) {
+    this.out(console.debug, [message, meta]);
+  }
+  debug(message, meta) {
+    this.out(console.debug, [message, meta]);
+  }
+  silly(message, meta) {
+    this.out(console.debug, [message, meta]);
+  }
+  displayAIResponse(response) {
+    this.out(console.log, [response]);
+  }
+  toolCall(toolName, args) {
+    this.out(console.log, ["Tool Call", toolName, args]);
+  }
+  toolResult(result) {
+    this.out(console.log, ["Tool Result", result]);
+  }
+  displayStartupInfo(info) {
+    this.out(console.log, ["Startup", info]);
+  }
+  displayError(message, error) {
+    this.out(console.error, [message, error]);
+  }
+  setLevel(level) {
+    this.level = level.toLowerCase();
+  }
+  getLevel() {
+    return this.level;
+  }
+  getLogFilePath() {
+    return null;
+  }
+}
+const logger = new Logger();
+export {
+  Logger,
+  logger
+};