@dexto/core 1.1.4

package/dist/chunk-MVKLS3LM.js

@@ -0,0 +1,43 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/.pnpm/tsup@8.5.0_jiti@2.5.1_postcss@8.5.6_tsx@4.20.5_typescript@5.9.2_yaml@2.8.1/node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var init_esm_shims = __esm({
+  "../../node_modules/.pnpm/tsup@8.5.0_jiti@2.5.1_postcss@8.5.6_tsx@4.20.5_typescript@5.9.2_yaml@2.8.1/node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
+
+export {
+  __commonJS,
+  __toESM,
+  init_esm_shims
+};

package/dist/chunk-PI6XFMEW.js

@@ -0,0 +1,141 @@
+import {
+  DextoRuntimeError
+} from "./chunk-TPERKLLN.js";
+import {
+  init_esm_shims
+} from "./chunk-MVKLS3LM.js";
+
+// src/agent/registry/errors.ts
+init_esm_shims();
+var RegistryError = class {
+  // Agent lookup errors
+  static agentNotFound(agentName, availableAgents) {
+    return new DextoRuntimeError(
+      "registry_agent_not_found" /* AGENT_NOT_FOUND */,
+      "agent_registry" /* AGENT_REGISTRY */,
+      "user" /* USER */,
+      `Agent '${agentName}' not found in registry`,
+      { agentName, availableAgents },
+      `Available agents: ${availableAgents.join(", ")}. Use a file path for custom agents.`
+    );
+  }
+  static agentInvalidEntry(agentName, reason) {
+    return new DextoRuntimeError(
+      "registry_agent_invalid_entry" /* AGENT_INVALID_ENTRY */,
+      "agent_registry" /* AGENT_REGISTRY */,
+      "system" /* SYSTEM */,
+      `Registry entry for '${agentName}' is invalid: ${reason}`,
+      { agentName, reason },
+      "This indicates a problem with the agent registry - please report this issue"
+    );
+  }
+  // Installation errors
+  static installationFailed(agentName, cause) {
+    return new DextoRuntimeError(
+      "registry_installation_failed" /* INSTALLATION_FAILED */,
+      "agent_registry" /* AGENT_REGISTRY */,
+      "system" /* SYSTEM */,
+      `Failed to install agent '${agentName}': ${cause}`,
+      { agentName, cause },
+      "Check network connection and available disk space"
+    );
+  }
+  static installationValidationFailed(agentName, missingPath) {
+    return new DextoRuntimeError(
+      "registry_installation_validation_failed" /* INSTALLATION_VALIDATION_FAILED */,
+      "agent_registry" /* AGENT_REGISTRY */,
+      "system" /* SYSTEM */,
+      `Installation validation failed for '${agentName}': missing main config`,
+      { agentName, missingPath },
+      "This indicates a problem with the agent bundle - please report this issue"
+    );
+  }
+  // Config file errors
+  static configNotFound(configPath) {
+    return new DextoRuntimeError(
+      "registry_config_not_found" /* CONFIG_NOT_FOUND */,
+      "agent_registry" /* AGENT_REGISTRY */,
+      "system" /* SYSTEM */,
+      `Agent config file not found: ${configPath}`,
+      { configPath },
+      "This indicates a problem with the agent installation"
+    );
+  }
+  static mainConfigMissing(agentName, expectedPath) {
+    return new DextoRuntimeError(
+      "registry_main_config_missing" /* MAIN_CONFIG_MISSING */,
+      "agent_registry" /* AGENT_REGISTRY */,
+      "system" /* SYSTEM */,
+      `Main config file not found for agent '${agentName}': ${expectedPath}`,
+      { agentName, expectedPath },
+      "This indicates a problem with the agent bundle structure"
+    );
+  }
+  // Uninstallation errors
+  static agentNotInstalled(agentName) {
+    return new DextoRuntimeError(
+      "registry_agent_not_installed" /* AGENT_NOT_INSTALLED */,
+      "agent_registry" /* AGENT_REGISTRY */,
+      "user" /* USER */,
+      `Agent '${agentName}' is not installed`,
+      { agentName },
+      'Use "dexto list-agents --installed" to see installed agents'
+    );
+  }
+  static agentProtected(agentName) {
+    return new DextoRuntimeError(
+      "registry_agent_protected" /* AGENT_PROTECTED */,
+      "agent_registry" /* AGENT_REGISTRY */,
+      "user" /* USER */,
+      `Agent '${agentName}' is protected and cannot be uninstalled. Use --force to override (not recommended for critical agents)`,
+      { agentName },
+      "Use --force to override (not recommended for critical agents)"
+    );
+  }
+  static uninstallationFailed(agentName, cause) {
+    return new DextoRuntimeError(
+      "registry_uninstallation_failed" /* UNINSTALLATION_FAILED */,
+      "agent_registry" /* AGENT_REGISTRY */,
+      "system" /* SYSTEM */,
+      `Failed to uninstall agent '${agentName}': ${cause}`,
+      { agentName, cause },
+      "Check file permissions and ensure no processes are using the agent"
+    );
+  }
+  // Registry file errors
+  static registryNotFound(registryPath) {
+    return new DextoRuntimeError(
+      "registry_file_not_found" /* REGISTRY_NOT_FOUND */,
+      "agent_registry" /* AGENT_REGISTRY */,
+      "system" /* SYSTEM */,
+      `Agent registry not found: ${registryPath}`,
+      { registryPath },
+      "This indicates a problem with the Dexto installation - please reinstall or report this issue"
+    );
+  }
+  static registryParseError(registryPath, cause) {
+    return new DextoRuntimeError(
+      "registry_parse_error" /* REGISTRY_PARSE_ERROR */,
+      "agent_registry" /* AGENT_REGISTRY */,
+      "system" /* SYSTEM */,
+      `Failed to parse agent registry from ${registryPath}: ${cause}`,
+      { registryPath, cause },
+      "This indicates a corrupted registry file - please reinstall Dexto"
+    );
+  }
+  // Auto-install control errors
+  static agentNotInstalledAutoInstallDisabled(agentName, availableAgents) {
+    return new DextoRuntimeError(
+      "registry_agent_not_installed_auto_install_disabled" /* AGENT_NOT_INSTALLED_AUTO_INSTALL_DISABLED */,
+      "agent_registry" /* AGENT_REGISTRY */,
+      "user" /* USER */,
+      `Agent '${agentName}' is not installed locally and auto-install is disabled`,
+      { agentName, availableAgents },
+      `Use 'dexto install ${agentName}' to install it manually, or use a file path for custom agents`
+    );
+  }
+};
+
+export {
+  RegistryError
+};

package/dist/chunk-TPERKLLN.js

@@ -0,0 +1,75 @@
+import {
+  init_esm_shims
+} from "./chunk-MVKLS3LM.js";
+
+// src/errors/DextoBaseError.ts
+init_esm_shims();
+import { randomUUID } from "crypto";
+var DextoBaseError = class extends Error {
+  traceId;
+  constructor(message, traceId) {
+    super(message);
+    this.traceId = traceId || randomUUID();
+    this.name = this.constructor.name;
+  }
+};
+
+// src/errors/DextoRuntimeError.ts
+init_esm_shims();
+var DextoRuntimeError = class 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
+    };
+  }
+};
+
+// src/errors/types.ts
+init_esm_shims();
+var ErrorScope = /* @__PURE__ */ ((ErrorScope2) => {
+  ErrorScope2["LLM"] = "llm";
+  ErrorScope2["AGENT"] = "agent";
+  ErrorScope2["CONFIG"] = "config";
+  ErrorScope2["CONTEXT"] = "context";
+  ErrorScope2["SESSION"] = "session";
+  ErrorScope2["MCP"] = "mcp";
+  ErrorScope2["TOOLS"] = "tools";
+  ErrorScope2["STORAGE"] = "storage";
+  ErrorScope2["SYSTEM_PROMPT"] = "system_prompt";
+  ErrorScope2["PREFERENCE"] = "preference";
+  ErrorScope2["AGENT_REGISTRY"] = "agent_registry";
+  return ErrorScope2;
+})(ErrorScope || {});
+var ErrorType = /* @__PURE__ */ ((ErrorType2) => {
+  ErrorType2["USER"] = "user";
+  ErrorType2["NOT_FOUND"] = "not_found";
+  ErrorType2["FORBIDDEN"] = "forbidden";
+  ErrorType2["TIMEOUT"] = "timeout";
+  ErrorType2["RATE_LIMIT"] = "rate_limit";
+  ErrorType2["SYSTEM"] = "system";
+  ErrorType2["THIRD_PARTY"] = "third_party";
+  ErrorType2["UNKNOWN"] = "unknown";
+  return ErrorType2;
+})(ErrorType || {});
+
+export {
+  DextoBaseError,
+  DextoRuntimeError,
+  ErrorScope,
+  ErrorType
+};

package/dist/chunk-XFQLRBHE.js

@@ -0,0 +1,122 @@
+import {
+  logger
+} from "./chunk-D62MHQBE.js";
+import {
+  DextoBaseError
+} from "./chunk-TPERKLLN.js";
+import {
+  init_esm_shims
+} from "./chunk-MVKLS3LM.js";
+
+// src/errors/DextoValidationError.ts
+init_esm_shims();
+var DextoValidationError = class _DextoValidationError extends DextoBaseError {
+  issues;
+  constructor(issues) {
+    const message = _DextoValidationError.formatMessage(issues);
+    super(message);
+    this.name = "DextoValidationError";
+    this.issues = issues;
+  }
+  /**
+   * Format multiple issues into a readable error message
+   */
+  static formatMessage(issues) {
+    if (issues.length === 0) {
+      return "Validation failed";
+    }
+    if (issues.length === 1) {
+      return issues[0].message;
+    }
+    const errors = issues.filter((i) => i.severity === "error");
+    const warnings = issues.filter((i) => i.severity === "warning");
+    const parts = [];
+    if (errors.length > 0) {
+      parts.push(`${errors.length} error${errors.length > 1 ? "s" : ""}`);
+    }
+    if (warnings.length > 0) {
+      parts.push(`${warnings.length} warning${warnings.length > 1 ? "s" : ""}`);
+    }
+    return `Validation failed with ${parts.join(" and ")}`;
+  }
+  /**
+   * Get only error-severity issues
+   */
+  get errors() {
+    return this.issues.filter((i) => i.severity === "error");
+  }
+  /**
+   * Get only warning-severity issues
+   */
+  get warnings() {
+    return this.issues.filter((i) => i.severity === "warning");
+  }
+  /**
+   * Check if there are any error-severity issues
+   */
+  hasErrors() {
+    return this.errors.length > 0;
+  }
+  /**
+   * Check if there are any warning-severity issues
+   */
+  hasWarnings() {
+    return this.warnings.length > 0;
+  }
+  /**
+   * Get the first error-severity issue (if any)
+   * Useful for getting the primary error when multiple exist
+   */
+  get firstError() {
+    return this.errors[0];
+  }
+  /**
+   * Get the first warning-severity issue (if any)
+   */
+  get firstWarning() {
+    return this.warnings[0];
+  }
+  /**
+   * Format issues for display
+   * Returns an object with categorized issues for easy logging
+   */
+  format() {
+    return {
+      errors: this.errors.map((e) => `[${e.code}] ${e.message}`),
+      warnings: this.warnings.map((w) => `[${w.code}] ${w.message}`)
+    };
+  }
+  /**
+   * Convert to JSON representation
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      issues: this.issues,
+      traceId: this.traceId,
+      errorCount: this.errors.length,
+      warningCount: this.warnings.length
+    };
+  }
+};
+
+// src/errors/result-bridge.ts
+init_esm_shims();
+function ensureOk(result) {
+  if (result.ok) {
+    return result.data;
+  }
+  logger.error(
+    `ensureOk: found validation errors, throwing DextoValidationError: ${result.issues}`
+  );
+  throw new DextoValidationError(result.issues);
+}
+
+// src/errors/index.ts
+init_esm_shims();
+
+export {
+  DextoValidationError,
+  ensureOk
+};

package/dist/errors-ZZ4Z3FKB.js

@@ -0,0 +1,10 @@
+import {
+  RegistryError
+} from "./chunk-PI6XFMEW.js";
+import "./chunk-XFQLRBHE.js";
+import "./chunk-D62MHQBE.js";
+import "./chunk-TPERKLLN.js";
+import "./chunk-MVKLS3LM.js";
+export {
+  RegistryError
+};

package/dist/index.browser.cjs

@@ -0,0 +1,250 @@
+"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);
+
+// src/index.browser.ts
+var index_browser_exports = {};
+__export(index_browser_exports, {
+  ErrorScope: () => ErrorScope,
+  ErrorType: () => ErrorType,
+  LLM_PROVIDERS: () => LLM_PROVIDERS,
+  LLM_ROUTERS: () => LLM_ROUTERS,
+  SUPPORTED_FILE_TYPES: () => SUPPORTED_FILE_TYPES,
+  toError: () => toError,
+  zodToIssues: () => zodToIssues
+});
+module.exports = __toCommonJS(index_browser_exports);
+
+// src/utils/redactor.ts
+var SENSITIVE_FIELDS = [
+  "apikey",
+  "api_key",
+  "token",
+  "access_token",
+  "refresh_token",
+  "password",
+  "secret"
+];
+var FILE_DATA_FIELDS = [
+  "base64",
+  "filedata",
+  "file_data",
+  "imagedata",
+  "image_data",
+  "audiodata",
+  "audio_data",
+  "data"
+];
+var SENSITIVE_PATTERNS = [
+  /\bsk-[A-Za-z0-9]{20,}\b/g,
+  // OpenAI API keys (at least 20 chars after sk-)
+  /\bBearer\s+[A-Za-z0-9\-_.=]+\b/gi,
+  // Bearer tokens
+  /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/g,
+  // Emails
+  /\beyJ[A-Za-z0-9_-]*\.[A-Za-z0-9_-]*\.[A-Za-z0-9_-]*/g
+  // JWT tokens
+];
+var REDACTED = "[REDACTED]";
+var REDACTED_CIRCULAR = "[REDACTED_CIRCULAR]";
+var FILE_DATA_TRUNCATED = "[FILE_DATA_TRUNCATED]";
+function isLargeBase64Data(value) {
+  return value.length > 1e3 && /^[A-Za-z0-9+/=]{1000,}$/.test(value.substring(0, 1e3));
+}
+function truncateFileData(value, key, parent) {
+  if (typeof value !== "string") return value;
+  const lowerKey = key.toLowerCase();
+  const hasFileContext = !!parent && ("mimeType" in parent || "filename" in parent || "fileName" in parent);
+  const looksLikeFileField = FILE_DATA_FIELDS.includes(lowerKey) || lowerKey === "data" && hasFileContext;
+  if (looksLikeFileField && isLargeBase64Data(value)) {
+    return `${FILE_DATA_TRUNCATED} (${value.length} chars)`;
+  }
+  return value;
+}
+function redactSensitiveData(input, seen = /* @__PURE__ */ new WeakSet()) {
+  if (typeof input === "string") {
+    let result = input;
+    for (const pattern of SENSITIVE_PATTERNS) {
+      result = result.replace(pattern, REDACTED);
+    }
+    return result;
+  }
+  if (Array.isArray(input)) {
+    if (seen.has(input)) return REDACTED_CIRCULAR;
+    seen.add(input);
+    return input.map((item) => redactSensitiveData(item, seen));
+  }
+  if (input && typeof input === "object") {
+    if (seen.has(input)) return REDACTED_CIRCULAR;
+    seen.add(input);
+    const result = {};
+    for (const [key, value] of Object.entries(input)) {
+      if (SENSITIVE_FIELDS.includes(key.toLowerCase())) {
+        result[key] = REDACTED;
+      } else {
+        const truncatedValue = truncateFileData(
+          value,
+          key,
+          input
+        );
+        result[key] = redactSensitiveData(truncatedValue, seen);
+      }
+    }
+    return result;
+  }
+  return input;
+}
+
+// src/utils/safe-stringify.ts
+function safeStringify(value, maxLen = 1e3) {
+  try {
+    if (typeof value === "bigint") {
+      return value.toString();
+    }
+    const redacted = redactSensitiveData(value);
+    const str = JSON.stringify(redacted, (_, v) => {
+      if (v instanceof Error) {
+        return { name: v.name, message: v.message, stack: v.stack };
+      }
+      if (typeof v === "bigint") return v.toString();
+      return v;
+    });
+    const indicator = "\u2026(truncated)";
+    const limit = Number.isFinite(maxLen) && maxLen > 0 ? Math.floor(maxLen) : 1e3;
+    if (typeof str === "string") {
+      if (str.length <= limit) return str;
+      const sliceLen = Math.max(0, limit - indicator.length);
+      return `${str.slice(0, sliceLen)}${indicator}`;
+    }
+    return String(value);
+  } catch {
+    try {
+      return String(value);
+    } catch {
+      return "[Unserializable value]";
+    }
+  }
+}
+
+// src/utils/error-conversion.ts
+function toError(error) {
+  if (error instanceof Error) {
+    return error;
+  }
+  if (error && typeof error === "object") {
+    if ("message" in error && typeof error.message === "string") {
+      return new Error(error.message, { cause: error });
+    }
+    if ("error" in error && typeof error.error === "string") {
+      return new Error(error.error, { cause: error });
+    }
+    if ("details" in error && typeof error.details === "string") {
+      return new Error(error.details, { cause: error });
+    }
+    if ("description" in error && typeof error.description === "string") {
+      return new Error(error.description, { cause: error });
+    }
+    const serialized = safeStringify(error);
+    return new Error(serialized);
+  }
+  if (typeof error === "string") {
+    return new Error(error, { cause: error });
+  }
+  return new Error(String(error), { cause: error });
+}
+
+// src/utils/result.ts
+var import_zod = require("zod");
+
+// src/errors/types.ts
+var ErrorScope = /* @__PURE__ */ ((ErrorScope2) => {
+  ErrorScope2["LLM"] = "llm";
+  ErrorScope2["AGENT"] = "agent";
+  ErrorScope2["CONFIG"] = "config";
+  ErrorScope2["CONTEXT"] = "context";
+  ErrorScope2["SESSION"] = "session";
+  ErrorScope2["MCP"] = "mcp";
+  ErrorScope2["TOOLS"] = "tools";
+  ErrorScope2["STORAGE"] = "storage";
+  ErrorScope2["SYSTEM_PROMPT"] = "system_prompt";
+  ErrorScope2["PREFERENCE"] = "preference";
+  ErrorScope2["AGENT_REGISTRY"] = "agent_registry";
+  return ErrorScope2;
+})(ErrorScope || {});
+var ErrorType = /* @__PURE__ */ ((ErrorType2) => {
+  ErrorType2["USER"] = "user";
+  ErrorType2["NOT_FOUND"] = "not_found";
+  ErrorType2["FORBIDDEN"] = "forbidden";
+  ErrorType2["TIMEOUT"] = "timeout";
+  ErrorType2["RATE_LIMIT"] = "rate_limit";
+  ErrorType2["SYSTEM"] = "system";
+  ErrorType2["THIRD_PARTY"] = "third_party";
+  ErrorType2["UNKNOWN"] = "unknown";
+  return ErrorType2;
+})(ErrorType || {});
+
+// src/utils/result.ts
+var NonEmptyTrimmed = import_zod.z.string().transform((s) => s.trim()).refine((s) => s.length > 0, { message: "Required" });
+function isValidUrl(s) {
+  try {
+    const u = new URL(s);
+    return u.protocol === "http:" || u.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+var OptionalURL = import_zod.z.string().transform((s) => s.trim()).refine((s) => s === "" || isValidUrl(s), { message: "Invalid URL" }).transform((s) => s === "" ? void 0 : s).optional();
+function zodToIssues(err, severity = "error") {
+  return err.errors.map((e) => {
+    const params = e.params || {};
+    return {
+      code: params.code ?? "schema_validation",
+      message: e.message,
+      scope: params.scope ?? "agent" /* AGENT */,
+      // Fallback for non-custom Zod errors
+      // Treat plain Zod schema failures as USER errors by default
+      type: params.type ?? "user" /* USER */,
+      path: e.path,
+      severity,
+      context: params
+    };
+  });
+}
+
+// src/llm/types.ts
+var LLM_PROVIDERS = [
+  "openai",
+  "openai-compatible",
+  "anthropic",
+  "google",
+  "groq",
+  "xai",
+  "cohere"
+];
+var LLM_ROUTERS = ["vercel", "in-built"];
+var SUPPORTED_FILE_TYPES = ["pdf", "image", "audio"];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ErrorScope,
+  ErrorType,
+  LLM_PROVIDERS,
+  LLM_ROUTERS,
+  SUPPORTED_FILE_TYPES,
+  toError,
+  zodToIssues
+});