@dexto/core 1.1.4 → 1.1.6

package/dist/logger/logger.js

@@ -0,0 +1,327 @@
+import * as winston from "winston";
+import chalk from "chalk";
+import boxen from "boxen";
+import * as fs from "fs";
+import * as path from "path";
+import { getDextoPath } from "../utils/path.js";
+const logLevels = {
+  error: 0,
+  warn: 1,
+  info: 2,
+  http: 3,
+  verbose: 4,
+  debug: 5,
+  silly: 6
+};
+const consoleFormat = winston.format.printf(({ level, message, timestamp, color }) => {
+  const levelColorMap = {
+    error: chalk.red,
+    warn: chalk.yellow,
+    info: chalk.blue,
+    http: chalk.cyan,
+    verbose: chalk.magenta,
+    debug: chalk.gray,
+    silly: chalk.gray.dim
+  };
+  const colorize = levelColorMap[level] || chalk.white;
+  const formattedMessage = color && typeof color === "string" && chalk[color] ? chalk[color](message) : message;
+  return `${chalk.dim(timestamp)} ${colorize(level.toUpperCase())}: ${formattedMessage}`;
+});
+const SHOULD_REDACT = process.env.REDACT_SECRETS !== "false";
+const SENSITIVE_KEYS = ["apiKey", "password", "secret", "token"];
+const MASK_REGEX = new RegExp(
+  `(${SENSITIVE_KEYS.join("|")})(["']?\\s*[:=]\\s*)(["'])?.*?\\3`,
+  "gi"
+);
+const maskFormat = winston.format((info) => {
+  if (SHOULD_REDACT && typeof info.message === "string") {
+    info.message = info.message.replace(MASK_REGEX, "$1$2$3[REDACTED]$3");
+  }
+  return info;
+});
+const getDefaultLogLevel = () => {
+  const envLevel = process.env.DEXTO_LOG_LEVEL;
+  if (envLevel && Object.keys(logLevels).includes(envLevel.toLowerCase())) {
+    return envLevel.toLowerCase();
+  }
+  return "info";
+};
+class Logger {
+  logger;
+  isSilent = false;
+  logFilePath = null;
+  logToConsole = false;
+  constructor(options = {}) {
+    this.isSilent = options.silent || false;
+    this.initializeTransports(options);
+    this.logger = winston.createLogger({
+      levels: logLevels,
+      level: options.level || getDefaultLogLevel(),
+      silent: options.silent || false,
+      format: winston.format.combine(
+        winston.format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }),
+        maskFormat(),
+        winston.format.errors({ stack: true }),
+        winston.format.splat(),
+        winston.format.json()
+      ),
+      transports: this.createTransports(options)
+    });
+  }
+  initializeTransports(options) {
+    const logToConsole = options.logToConsole ?? process.env.DEXTO_LOG_TO_CONSOLE === "true";
+    this.logToConsole = logToConsole;
+    if (options.customLogPath) {
+      this.logFilePath = options.customLogPath;
+    } else {
+      this.logFilePath = getDextoPath("logs", "dexto.log");
+    }
+  }
+  createTransports(_options) {
+    const transports = [];
+    if (this.logToConsole) {
+      transports.push(
+        new winston.transports.Console({
+          format: winston.format.combine(
+            winston.format.timestamp({ format: "HH:mm:ss" }),
+            maskFormat(),
+            consoleFormat
+          )
+        })
+      );
+    }
+    try {
+      if (this.logFilePath) {
+        const logDir = path.dirname(this.logFilePath);
+        fs.mkdirSync(logDir, { recursive: true });
+        transports.push(
+          new winston.transports.File({
+            filename: this.logFilePath,
+            format: winston.format.combine(
+              winston.format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }),
+              maskFormat(),
+              winston.format.errors({ stack: true }),
+              winston.format.json()
+            ),
+            // Add daily rotation
+            maxsize: 10 * 1024 * 1024,
+            // 10MB
+            maxFiles: 7,
+            // Keep 7 files
+            tailable: true
+          })
+        );
+      }
+    } catch (error) {
+      console.error(`Failed to initialize file logging: ${error}. Falling back to console.`);
+      if (!this.logToConsole) {
+        this.logToConsole = true;
+        transports.push(
+          new winston.transports.Console({
+            format: winston.format.combine(
+              winston.format.timestamp({ format: "HH:mm:ss" }),
+              maskFormat(),
+              consoleFormat
+            )
+          })
+        );
+      }
+    }
+    return transports;
+  }
+  // General logging methods with optional color parameter
+  error(message, meta, color) {
+    this.logger.error(message, { ...meta, color });
+  }
+  warn(message, meta, color) {
+    this.logger.warn(message, { ...meta, color });
+  }
+  info(message, meta, color) {
+    this.logger.info(message, { ...meta, color });
+  }
+  http(message, meta, color) {
+    this.logger.http(message, { ...meta, color });
+  }
+  verbose(message, meta, color) {
+    this.logger.verbose(message, { ...meta, color });
+  }
+  debug(message, meta, color) {
+    const formattedMessage = typeof message === "string" ? message : JSON.stringify(message, null, 2);
+    this.logger.debug(formattedMessage, { ...meta, color });
+  }
+  silly(message, meta, color) {
+    this.logger.silly(message, { ...meta, color });
+  }
+  // Display AI response in a box
+  displayAIResponse(response) {
+    if (this.isSilent) return;
+    if (response.content) {
+      console.log(
+        boxen(chalk.white(response.content), {
+          padding: 1,
+          borderColor: "yellow",
+          title: "\u{1F916} AI Response",
+          titleAlignment: "center"
+        })
+      );
+    } else {
+      console.log(chalk.yellow("AI is thinking..."));
+    }
+  }
+  // Tool-related logging
+  toolCall(toolName, args) {
+    if (this.isSilent) return;
+    console.log(
+      boxen(
+        `${chalk.cyan("Tool Call")}: ${chalk.yellow(toolName)}
+${chalk.dim("Arguments")}:
+${chalk.white(JSON.stringify(args, null, 2))}`,
+        { padding: 1, borderColor: "blue", title: "\u{1F527} Tool Call", titleAlignment: "center" }
+      )
+    );
+  }
+  toolResult(result) {
+    if (this.isSilent) return;
+    let displayText = "";
+    let isError = false;
+    let borderColor = "green";
+    let title = "\u2705 Tool Result";
+    if (result?.error || result?.isError) {
+      isError = true;
+      borderColor = "yellow";
+      title = "\u26A0\uFE0F Tool Result (Error)";
+    }
+    if (result?.content && Array.isArray(result.content)) {
+      result.content.forEach((item) => {
+        if (item.type === "text") {
+          displayText += item.text;
+        } else if (item.type === "image" && item.url) {
+          displayText += `[Image URL: ${item.url}]`;
+        } else if (item.type === "image") {
+          displayText += `[Image Data: ${item.mimeType || "unknown type"}]`;
+        } else if (item.type === "markdown") {
+          displayText += item.markdown;
+        } else {
+          displayText += `[Unsupported content type: ${item.type}]`;
+        }
+        displayText += "\n";
+      });
+    } else if (result?.message) {
+      displayText = result.message;
+      isError = true;
+      borderColor = "red";
+      title = "\u274C Tool Error";
+    } else if (typeof result === "string") {
+      if (result.length > 1e3) {
+        displayText = `${result.slice(0, 500)}... [${result.length - 500} chars omitted]`;
+      } else {
+        displayText = result;
+      }
+    } else {
+      try {
+        const resultStr = JSON.stringify(result, null, 2);
+        if (resultStr.length > 2e3) {
+          displayText = `${resultStr.slice(0, 1e3)}... [${resultStr.length - 1e3} chars omitted]`;
+        } else {
+          displayText = resultStr;
+        }
+      } catch {
+        displayText = `[Unparseable result: ${typeof result}]`;
+      }
+    }
+    if (!displayText || displayText.trim() === "") {
+      displayText = "[Empty result]";
+    }
+    const textColor = isError ? chalk.yellow : chalk.green;
+    console.log(
+      boxen(textColor(displayText), {
+        padding: 1,
+        borderColor,
+        title,
+        titleAlignment: "center"
+      })
+    );
+  }
+  // Configuration
+  setLevel(level) {
+    if (Object.keys(logLevels).includes(level.toLowerCase())) {
+      this.logger.level = level.toLowerCase();
+      if (!this.isSilent) {
+        console.log(`Log level set to: ${level}`);
+      }
+    } else {
+      this.error(`Invalid log level: ${level}. Using current level: ${this.logger.level}`);
+    }
+  }
+  // Get the current log file path
+  getLogFilePath() {
+    return this.logFilePath;
+  }
+  // Get current log level
+  getLevel() {
+    return this.logger.level;
+  }
+  // CLI startup information display methods
+  displayStartupInfo(info) {
+    if (this.isSilent) return;
+    console.log("");
+    if (info.model && info.provider) {
+      console.log(
+        `\u{1F916} ${chalk.bold("Current Model:")} ${chalk.cyan(info.model)} ${chalk.dim(`(${info.provider})`)}`
+      );
+    }
+    if (info.connectedServers) {
+      if (info.connectedServers.count > 0) {
+        const serverNames = info.connectedServers.names.join(", ");
+        console.log(
+          `\u{1F517} ${chalk.bold("Connected Servers:")} ${chalk.green(info.connectedServers.count)} ${chalk.dim(`(${serverNames})`)}`
+        );
+      } else {
+        console.log(
+          `\u{1F517} ${chalk.bold("Connected Servers:")} ${chalk.yellow("0")} ${chalk.dim("(no MCP servers connected)")}`
+        );
+      }
+    }
+    if (info.failedConnections && Object.keys(info.failedConnections).length > 0) {
+      const failedNames = Object.keys(info.failedConnections);
+      console.log(
+        `\u274C ${chalk.bold("Failed Connections:")} ${chalk.red(failedNames.length)} ${chalk.dim(`(${failedNames.join(", ")})`)}`
+      );
+      for (const [serverName, error] of Object.entries(info.failedConnections)) {
+        console.log(`   ${chalk.red("\u2022")} ${chalk.dim(serverName)}: ${chalk.red(error)}`);
+      }
+    }
+    if (info.toolStats) {
+      console.log(
+        `\u{1F6E0}\uFE0F  ${chalk.bold("Available Tools:")} ${chalk.green(info.toolStats.total)} total ${chalk.dim(`(${info.toolStats.mcp} MCP, ${info.toolStats.internal} internal)`)}`
+      );
+    }
+    if (info.sessionId) {
+      console.log(`\u{1F4AC} ${chalk.bold("Session:")} ${chalk.blue(info.sessionId)}`);
+    }
+    if (info.logLevel && info.logFile) {
+      console.log(
+        `\u{1F4CB} ${chalk.bold("Log Level:")} ${chalk.cyan(info.logLevel)} ${chalk.dim(`(file: ${info.logFile})`)}`
+      );
+    }
+  }
+  displayError(message, error) {
+    if (this.isSilent) return;
+    const showStack = this.getLevel() === "debug";
+    const errorContent = error?.stack && showStack ? `${chalk.red("Error")}: ${chalk.red(message)}
+${chalk.dim(error.stack)}` : `${chalk.red("Error")}: ${chalk.red(message)}`;
+    console.log(
+      boxen(errorContent, {
+        padding: 1,
+        borderColor: "red",
+        title: "\u274C Error",
+        titleAlignment: "center"
+      })
+    );
+  }
+}
+const logger = new Logger();
+export {
+  Logger,
+  logger
+};

package/dist/mcp/error-codes.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 error_codes_exports = {};
+__export(error_codes_exports, {
+  MCPErrorCode: () => MCPErrorCode
+});
+module.exports = __toCommonJS(error_codes_exports);
+var MCPErrorCode = /* @__PURE__ */ ((MCPErrorCode2) => {
+  MCPErrorCode2["SCHEMA_VALIDATION"] = "mcp_schema_validation";
+  MCPErrorCode2["COMMAND_MISSING"] = "mcp_command_missing";
+  MCPErrorCode2["DUPLICATE_NAME"] = "mcp_duplicate_name";
+  MCPErrorCode2["CONNECTION_FAILED"] = "mcp_connection_failed";
+  MCPErrorCode2["PROTOCOL_ERROR"] = "mcp_protocol_error";
+  MCPErrorCode2["TOOL_NOT_FOUND"] = "mcp_tool_not_found";
+  MCPErrorCode2["PROMPT_NOT_FOUND"] = "mcp_prompt_not_found";
+  MCPErrorCode2["RESOURCE_NOT_FOUND"] = "mcp_resource_not_found";
+  return MCPErrorCode2;
+})(MCPErrorCode || {});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MCPErrorCode
+});

package/dist/mcp/error-codes.d.cts

@@ -0,0 +1,16 @@
+/**
+ * MCP-specific error codes
+ * Includes server configuration, connection, and protocol errors
+ */
+declare enum MCPErrorCode {
+    SCHEMA_VALIDATION = "mcp_schema_validation",
+    COMMAND_MISSING = "mcp_command_missing",
+    DUPLICATE_NAME = "mcp_duplicate_name",
+    CONNECTION_FAILED = "mcp_connection_failed",
+    PROTOCOL_ERROR = "mcp_protocol_error",
+    TOOL_NOT_FOUND = "mcp_tool_not_found",
+    PROMPT_NOT_FOUND = "mcp_prompt_not_found",
+    RESOURCE_NOT_FOUND = "mcp_resource_not_found"
+}
+
+export { MCPErrorCode };

package/dist/mcp/error-codes.d.ts

@@ -0,0 +1,16 @@
+/**
+ * MCP-specific error codes
+ * Includes server configuration, connection, and protocol errors
+ */
+declare enum MCPErrorCode {
+    SCHEMA_VALIDATION = "mcp_schema_validation",
+    COMMAND_MISSING = "mcp_command_missing",
+    DUPLICATE_NAME = "mcp_duplicate_name",
+    CONNECTION_FAILED = "mcp_connection_failed",
+    PROTOCOL_ERROR = "mcp_protocol_error",
+    TOOL_NOT_FOUND = "mcp_tool_not_found",
+    PROMPT_NOT_FOUND = "mcp_prompt_not_found",
+    RESOURCE_NOT_FOUND = "mcp_resource_not_found"
+}
+
+export { MCPErrorCode };

package/dist/mcp/error-codes.js

@@ -0,0 +1,14 @@
+var MCPErrorCode = /* @__PURE__ */ ((MCPErrorCode2) => {
+  MCPErrorCode2["SCHEMA_VALIDATION"] = "mcp_schema_validation";
+  MCPErrorCode2["COMMAND_MISSING"] = "mcp_command_missing";
+  MCPErrorCode2["DUPLICATE_NAME"] = "mcp_duplicate_name";
+  MCPErrorCode2["CONNECTION_FAILED"] = "mcp_connection_failed";
+  MCPErrorCode2["PROTOCOL_ERROR"] = "mcp_protocol_error";
+  MCPErrorCode2["TOOL_NOT_FOUND"] = "mcp_tool_not_found";
+  MCPErrorCode2["PROMPT_NOT_FOUND"] = "mcp_prompt_not_found";
+  MCPErrorCode2["RESOURCE_NOT_FOUND"] = "mcp_resource_not_found";
+  return MCPErrorCode2;
+})(MCPErrorCode || {});
+export {
+  MCPErrorCode
+};

package/dist/mcp/errors.cjs

@@ -0,0 +1,131 @@
+"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, {
+  MCPError: () => MCPError
+});
+module.exports = __toCommonJS(errors_exports);
+var import_DextoRuntimeError = require("../errors/DextoRuntimeError.cjs");
+var import_types = require("../errors/types.cjs");
+var import_error_codes = require("./error-codes.js");
+class MCPError {
+  /**
+   * MCP server connection failed
+   */
+  static connectionFailed(serverName, reason) {
+    return new import_DextoRuntimeError.DextoRuntimeError(
+      import_error_codes.MCPErrorCode.CONNECTION_FAILED,
+      import_types.ErrorScope.MCP,
+      import_types.ErrorType.THIRD_PARTY,
+      `Failed to connect to MCP server '${serverName}': ${reason}`,
+      { serverName, reason },
+      "Check that the MCP server is running and accessible"
+    );
+  }
+  /**
+   * MCP protocol error
+   */
+  static protocolError(message, details) {
+    return new import_DextoRuntimeError.DextoRuntimeError(
+      import_error_codes.MCPErrorCode.PROTOCOL_ERROR,
+      import_types.ErrorScope.MCP,
+      import_types.ErrorType.THIRD_PARTY,
+      `MCP protocol error: ${message}`,
+      details,
+      "Check MCP server compatibility and protocol version"
+    );
+  }
+  /**
+   * MCP duplicate server name
+   */
+  static duplicateName(name, existingName) {
+    return new import_DextoRuntimeError.DextoRuntimeError(
+      import_error_codes.MCPErrorCode.DUPLICATE_NAME,
+      import_types.ErrorScope.MCP,
+      import_types.ErrorType.USER,
+      `Server name '${name}' conflicts with existing '${existingName}'`,
+      { name, existingName },
+      "Use a unique name for each MCP server"
+    );
+  }
+  /**
+   * MCP tool not found
+   */
+  static toolNotFound(toolName) {
+    return new import_DextoRuntimeError.DextoRuntimeError(
+      import_error_codes.MCPErrorCode.TOOL_NOT_FOUND,
+      import_types.ErrorScope.MCP,
+      import_types.ErrorType.NOT_FOUND,
+      `No MCP tool found: ${toolName}`,
+      { toolName }
+    );
+  }
+  /**
+   * MCP prompt not found
+   */
+  static promptNotFound(promptName) {
+    return new import_DextoRuntimeError.DextoRuntimeError(
+      import_error_codes.MCPErrorCode.PROMPT_NOT_FOUND,
+      import_types.ErrorScope.MCP,
+      import_types.ErrorType.NOT_FOUND,
+      `No client found for prompt: ${promptName}`,
+      { promptName }
+    );
+  }
+  /**
+   * MCP resource not found
+   */
+  static resourceNotFound(resourceUri) {
+    return new import_DextoRuntimeError.DextoRuntimeError(
+      import_error_codes.MCPErrorCode.RESOURCE_NOT_FOUND,
+      import_types.ErrorScope.MCP,
+      import_types.ErrorType.NOT_FOUND,
+      `No client found for resource: ${resourceUri}`,
+      { resourceUri }
+    );
+  }
+  /**
+   * MCP client not connected
+   */
+  static clientNotConnected(context) {
+    return new import_DextoRuntimeError.DextoRuntimeError(
+      import_error_codes.MCPErrorCode.CONNECTION_FAILED,
+      import_types.ErrorScope.MCP,
+      import_types.ErrorType.SYSTEM,
+      `MCP client is not connected${context ? `: ${context}` : ""}`,
+      { context }
+    );
+  }
+  /**
+   * Invalid tool schema
+   */
+  static invalidToolSchema(toolName, reason) {
+    return new import_DextoRuntimeError.DextoRuntimeError(
+      import_error_codes.MCPErrorCode.PROTOCOL_ERROR,
+      import_types.ErrorScope.MCP,
+      import_types.ErrorType.THIRD_PARTY,
+      `Tool '${toolName}' has invalid schema: ${reason}`,
+      { toolName, reason }
+    );
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MCPError
+});

package/dist/mcp/errors.d.cts

@@ -0,0 +1,72 @@
+import { DextoRuntimeError } from '../errors/DextoRuntimeError.cjs';
+import '../errors/DextoBaseError.cjs';
+import '../errors/types.cjs';
+import '../agent/error-codes.cjs';
+import '../config/error-codes.cjs';
+import '../context/error-codes.cjs';
+import '../llm/error-codes.cjs';
+import './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';
+
+/**
+ * MCP-specific error factory
+ * Creates properly typed errors for MCP operations
+ */
+declare class MCPError {
+    /**
+     * MCP server connection failed
+     */
+    static connectionFailed(serverName: string, reason: string): DextoRuntimeError<{
+        serverName: string;
+        reason: string;
+    }>;
+    /**
+     * MCP protocol error
+     */
+    static protocolError(message: string, details?: unknown): DextoRuntimeError<unknown>;
+    /**
+     * MCP duplicate server name
+     */
+    static duplicateName(name: string, existingName: string): DextoRuntimeError<{
+        name: string;
+        existingName: string;
+    }>;
+    /**
+     * MCP tool not found
+     */
+    static toolNotFound(toolName: string): DextoRuntimeError<{
+        toolName: string;
+    }>;
+    /**
+     * MCP prompt not found
+     */
+    static promptNotFound(promptName: string): DextoRuntimeError<{
+        promptName: string;
+    }>;
+    /**
+     * MCP resource not found
+     */
+    static resourceNotFound(resourceUri: string): DextoRuntimeError<{
+        resourceUri: string;
+    }>;
+    /**
+     * MCP client not connected
+     */
+    static clientNotConnected(context?: string): DextoRuntimeError<{
+        context: string | undefined;
+    }>;
+    /**
+     * Invalid tool schema
+     */
+    static invalidToolSchema(toolName: string, reason: string): DextoRuntimeError<{
+        toolName: string;
+        reason: string;
+    }>;
+}
+
+export { MCPError };

package/dist/mcp/errors.d.ts

@@ -0,0 +1,72 @@
+import { DextoRuntimeError } from '../errors/DextoRuntimeError.js';
+import '../errors/DextoBaseError.js';
+import '../errors/types.js';
+import '../agent/error-codes.js';
+import '../config/error-codes.js';
+import '../context/error-codes.js';
+import '../llm/error-codes.js';
+import './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';
+
+/**
+ * MCP-specific error factory
+ * Creates properly typed errors for MCP operations
+ */
+declare class MCPError {
+    /**
+     * MCP server connection failed
+     */
+    static connectionFailed(serverName: string, reason: string): DextoRuntimeError<{
+        serverName: string;
+        reason: string;
+    }>;
+    /**
+     * MCP protocol error
+     */
+    static protocolError(message: string, details?: unknown): DextoRuntimeError<unknown>;
+    /**
+     * MCP duplicate server name
+     */
+    static duplicateName(name: string, existingName: string): DextoRuntimeError<{
+        name: string;
+        existingName: string;
+    }>;
+    /**
+     * MCP tool not found
+     */
+    static toolNotFound(toolName: string): DextoRuntimeError<{
+        toolName: string;
+    }>;
+    /**
+     * MCP prompt not found
+     */
+    static promptNotFound(promptName: string): DextoRuntimeError<{
+        promptName: string;
+    }>;
+    /**
+     * MCP resource not found
+     */
+    static resourceNotFound(resourceUri: string): DextoRuntimeError<{
+        resourceUri: string;
+    }>;
+    /**
+     * MCP client not connected
+     */
+    static clientNotConnected(context?: string): DextoRuntimeError<{
+        context: string | undefined;
+    }>;
+    /**
+     * Invalid tool schema
+     */
+    static invalidToolSchema(toolName: string, reason: string): DextoRuntimeError<{
+        toolName: string;
+        reason: string;
+    }>;
+}
+
+export { MCPError };