@dexto/core 1.1.4 → 1.1.6

package/dist/errors/DextoValidationError.cjs

@@ -0,0 +1,118 @@
+"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 DextoValidationError_exports = {};
+__export(DextoValidationError_exports, {
+  DextoValidationError: () => DextoValidationError
+});
+module.exports = __toCommonJS(DextoValidationError_exports);
+var import_DextoBaseError = require("./DextoBaseError.js");
+class DextoValidationError extends import_DextoBaseError.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
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DextoValidationError
+});

package/dist/errors/DextoValidationError.d.cts

@@ -0,0 +1,65 @@
+import { DextoBaseError } from './DextoBaseError.cjs';
+import { Issue } 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';
+
+/**
+ * Validation error class for handling multiple validation issues
+ * Similar to ZodError, provides first-class access to all validation issues
+ */
+declare class DextoValidationError extends DextoBaseError {
+    readonly issues: Issue[];
+    constructor(issues: Issue[]);
+    /**
+     * Format multiple issues into a readable error message
+     */
+    private static formatMessage;
+    /**
+     * Get only error-severity issues
+     */
+    get errors(): Issue[];
+    /**
+     * Get only warning-severity issues
+     */
+    get warnings(): Issue[];
+    /**
+     * Check if there are any error-severity issues
+     */
+    hasErrors(): boolean;
+    /**
+     * Check if there are any warning-severity issues
+     */
+    hasWarnings(): boolean;
+    /**
+     * Get the first error-severity issue (if any)
+     * Useful for getting the primary error when multiple exist
+     */
+    get firstError(): Issue | undefined;
+    /**
+     * Get the first warning-severity issue (if any)
+     */
+    get firstWarning(): Issue | undefined;
+    /**
+     * Format issues for display
+     * Returns an object with categorized issues for easy logging
+     */
+    format(): {
+        errors: string[];
+        warnings: string[];
+    };
+    /**
+     * Convert to JSON representation
+     */
+    toJSON(): Record<string, any>;
+}
+
+export { DextoValidationError };

package/dist/errors/DextoValidationError.d.ts

@@ -0,0 +1,65 @@
+import { DextoBaseError } from './DextoBaseError.js';
+import { Issue } 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';
+
+/**
+ * Validation error class for handling multiple validation issues
+ * Similar to ZodError, provides first-class access to all validation issues
+ */
+declare class DextoValidationError extends DextoBaseError {
+    readonly issues: Issue[];
+    constructor(issues: Issue[]);
+    /**
+     * Format multiple issues into a readable error message
+     */
+    private static formatMessage;
+    /**
+     * Get only error-severity issues
+     */
+    get errors(): Issue[];
+    /**
+     * Get only warning-severity issues
+     */
+    get warnings(): Issue[];
+    /**
+     * Check if there are any error-severity issues
+     */
+    hasErrors(): boolean;
+    /**
+     * Check if there are any warning-severity issues
+     */
+    hasWarnings(): boolean;
+    /**
+     * Get the first error-severity issue (if any)
+     * Useful for getting the primary error when multiple exist
+     */
+    get firstError(): Issue | undefined;
+    /**
+     * Get the first warning-severity issue (if any)
+     */
+    get firstWarning(): Issue | undefined;
+    /**
+     * Format issues for display
+     * Returns an object with categorized issues for easy logging
+     */
+    format(): {
+        errors: string[];
+        warnings: string[];
+    };
+    /**
+     * Convert to JSON representation
+     */
+    toJSON(): Record<string, any>;
+}
+
+export { DextoValidationError };

package/dist/{chunk-XFQLRBHE.js → errors/DextoValidationError.js}

@@ -1,19 +1,8 @@
-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 {
+import { DextoBaseError } from "./DextoBaseError.js";
+class DextoValidationError extends DextoBaseError {
   issues;
   constructor(issues) {
-    const message = _DextoValidationError.formatMessage(issues);
+    const message = DextoValidationError.formatMessage(issues);
     super(message);
     this.name = "DextoValidationError";
     this.issues = issues;
@@ -99,24 +88,7 @@ var DextoValidationError = class _DextoValidationError extends DextoBaseError {
       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
+  DextoValidationError
 };

package/dist/errors/index.cjs

@@ -0,0 +1,42 @@
+"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 errors_exports = {};
+__export(errors_exports, {
+  DextoBaseError: () => import_DextoBaseError.DextoBaseError,
+  DextoRuntimeError: () => import_DextoRuntimeError.DextoRuntimeError,
+  DextoValidationError: () => import_DextoValidationError.DextoValidationError,
+  ErrorScope: () => import_types.ErrorScope,
+  ErrorType: () => import_types.ErrorType,
+  ensureOk: () => import_result_bridge.ensureOk
+});
+module.exports = __toCommonJS(errors_exports);
+var import_DextoBaseError = require("./DextoBaseError.js");
+var import_DextoRuntimeError = require("./DextoRuntimeError.js");
+var import_DextoValidationError = require("./DextoValidationError.js");
+var import_types = require("./types.js");
+var import_result_bridge = require("./result-bridge.js");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DextoBaseError,
+  DextoRuntimeError,
+  DextoValidationError,
+  ErrorScope,
+  ErrorType,
+  ensureOk
+});

package/dist/errors/index.d.cts

@@ -0,0 +1,18 @@
+export { DextoBaseError } from './DextoBaseError.cjs';
+export { DextoRuntimeError } from './DextoRuntimeError.cjs';
+export { DextoValidationError } from './DextoValidationError.cjs';
+export { DextoErrorCode, ErrorScope, ErrorType, Issue, Severity } from './types.cjs';
+export { ensureOk } from './result-bridge.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';
+import '../utils/result.cjs';
+import 'zod';

package/dist/errors/index.d.ts

@@ -0,0 +1,18 @@
+export { DextoBaseError } from './DextoBaseError.js';
+export { DextoRuntimeError } from './DextoRuntimeError.js';
+export { DextoValidationError } from './DextoValidationError.js';
+export { DextoErrorCode, ErrorScope, ErrorType, Issue, Severity } from './types.js';
+export { ensureOk } from './result-bridge.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';
+import '../utils/result.js';
+import 'zod';

package/dist/errors/index.js

@@ -0,0 +1,13 @@
+import { DextoBaseError } from "./DextoBaseError.js";
+import { DextoRuntimeError } from "./DextoRuntimeError.js";
+import { DextoValidationError } from "./DextoValidationError.js";
+import { ErrorScope, ErrorType } from "./types.js";
+import { ensureOk } from "./result-bridge.js";
+export {
+  DextoBaseError,
+  DextoRuntimeError,
+  DextoValidationError,
+  ErrorScope,
+  ErrorType,
+  ensureOk
+};

package/dist/errors/result-bridge.cjs

@@ -0,0 +1,38 @@
+"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 result_bridge_exports = {};
+__export(result_bridge_exports, {
+  ensureOk: () => ensureOk
+});
+module.exports = __toCommonJS(result_bridge_exports);
+var import_DextoValidationError = require("./DextoValidationError.js");
+var import_logger = require("../logger/index.js");
+function ensureOk(result) {
+  if (result.ok) {
+    return result.data;
+  }
+  import_logger.logger.error(
+    `ensureOk: found validation errors, throwing DextoValidationError: ${result.issues}`
+  );
+  throw new import_DextoValidationError.DextoValidationError(result.issues);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ensureOk
+});

package/dist/errors/result-bridge.d.cts

@@ -0,0 +1,39 @@
+import { Result } from '../utils/result.cjs';
+import 'zod';
+import './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';
+
+/**
+ * Bridge function to convert Result pattern to validation exceptions
+ * Used at public API boundaries for validation flows
+ *
+ * Note: Runtime errors are thrown directly, not through Result pattern
+ *
+ * @param result - The Result to check (typically from validation functions)
+ * @returns The data if successful
+ * @throws DextoValidationError if the result contains validation issues
+ *
+ * @example
+ * ```typescript
+ * // Validation flow
+ * const result = validateInputForLLM(input, config);
+ * const data = ensureOk(result); // Throws DextoValidationError if validation failed
+ *
+ * // LLM config validation
+ * const configResult = resolveAndValidateLLMConfig(current, updates);
+ * const validatedConfig = ensureOk(configResult);
+ * ```
+ */
+declare function ensureOk<T, C>(result: Result<T, C>): T;
+
+export { ensureOk };

package/dist/errors/result-bridge.d.ts

@@ -0,0 +1,39 @@
+import { Result } from '../utils/result.js';
+import 'zod';
+import './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';
+
+/**
+ * Bridge function to convert Result pattern to validation exceptions
+ * Used at public API boundaries for validation flows
+ *
+ * Note: Runtime errors are thrown directly, not through Result pattern
+ *
+ * @param result - The Result to check (typically from validation functions)
+ * @returns The data if successful
+ * @throws DextoValidationError if the result contains validation issues
+ *
+ * @example
+ * ```typescript
+ * // Validation flow
+ * const result = validateInputForLLM(input, config);
+ * const data = ensureOk(result); // Throws DextoValidationError if validation failed
+ *
+ * // LLM config validation
+ * const configResult = resolveAndValidateLLMConfig(current, updates);
+ * const validatedConfig = ensureOk(configResult);
+ * ```
+ */
+declare function ensureOk<T, C>(result: Result<T, C>): T;
+
+export { ensureOk };

package/dist/errors/result-bridge.js

@@ -0,0 +1,14 @@
+import { DextoValidationError } from "./DextoValidationError.js";
+import { logger } from "../logger/index.js";
+function ensureOk(result) {
+  if (result.ok) {
+    return result.data;
+  }
+  logger.error(
+    `ensureOk: found validation errors, throwing DextoValidationError: ${result.issues}`
+  );
+  throw new DextoValidationError(result.issues);
+}
+export {
+  ensureOk
+};

package/dist/errors/types.cjs

@@ -0,0 +1,54 @@
+"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 types_exports = {};
+__export(types_exports, {
+  ErrorScope: () => ErrorScope,
+  ErrorType: () => ErrorType
+});
+module.exports = __toCommonJS(types_exports);
+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 || {});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ErrorScope,
+  ErrorType
+});

package/dist/errors/types.d.cts

@@ -0,0 +1,62 @@
+import { AgentErrorCode } from '../agent/error-codes.cjs';
+import { ConfigErrorCode } from '../config/error-codes.cjs';
+import { ContextErrorCode } from '../context/error-codes.cjs';
+import { LLMErrorCode } from '../llm/error-codes.cjs';
+import { MCPErrorCode } from '../mcp/error-codes.cjs';
+import { SessionErrorCode } from '../session/error-codes.cjs';
+import { StorageErrorCode } from '../storage/error-codes.cjs';
+import { SystemPromptErrorCode } from '../systemPrompt/error-codes.cjs';
+import { ToolErrorCode } from '../tools/error-codes.cjs';
+import { PreferenceErrorCode } from '../preferences/error-codes.cjs';
+import { RegistryErrorCode } from '../agent/registry/error-codes.cjs';
+
+/**
+ * Error scopes representing functional domains in the system
+ * Each scope owns its validation and error logic
+ */
+declare enum ErrorScope {
+    LLM = "llm",// LLM operations, model compatibility, input validation for LLMs
+    AGENT = "agent",// Agent lifecycle, configuration
+    CONFIG = "config",// Configuration file operations, parsing, validation
+    CONTEXT = "context",// Context management, message validation, token processing
+    SESSION = "session",// Session lifecycle, management, and state
+    MCP = "mcp",// MCP server connections and protocol
+    TOOLS = "tools",// Tool execution and authorization
+    STORAGE = "storage",// Storage backend operations
+    SYSTEM_PROMPT = "system_prompt",// System prompt contributors and file processing
+    PREFERENCE = "preference",// Global preferences file operations and validation
+    AGENT_REGISTRY = "agent_registry"
+}
+/**
+ * Error types that map directly to HTTP status codes
+ * Each type represents the nature of the error
+ */
+declare enum ErrorType {
+    USER = "user",// 400 - bad input, config errors, validation failures
+    NOT_FOUND = "not_found",// 404 - resource doesn't exist (session, file, etc.)
+    FORBIDDEN = "forbidden",// 403 - permission denied, unauthorized
+    TIMEOUT = "timeout",// 408 - operation timed out
+    RATE_LIMIT = "rate_limit",// 429 - too many requests
+    SYSTEM = "system",// 500 - bugs, internal failures, unexpected states
+    THIRD_PARTY = "third_party",// 502 - upstream provider failures, API errors
+    UNKNOWN = "unknown"
+}
+/**
+ * Union type for all error codes across domains
+ * Provides type safety for error handling
+ */
+type DextoErrorCode = LLMErrorCode | AgentErrorCode | ConfigErrorCode | ContextErrorCode | SessionErrorCode | MCPErrorCode | ToolErrorCode | StorageErrorCode | SystemPromptErrorCode | PreferenceErrorCode | RegistryErrorCode;
+/** Severity of an issue */
+type Severity = 'error' | 'warning';
+/** Generic issue type for validation results */
+interface Issue<C = unknown> {
+    code: DextoErrorCode;
+    message: string;
+    scope: ErrorScope;
+    type: ErrorType;
+    severity: Severity;
+    path?: Array<string | number>;
+    context?: C;
+}
+
+export { type DextoErrorCode, ErrorScope, ErrorType, type Issue, type Severity };