@dexto/core 1.1.10 → 1.2.0

package/dist/approval/errors.js

@@ -0,0 +1,228 @@
+import "../chunk-C6A6W6XS.js";
+import { DextoRuntimeError, ErrorScope, ErrorType } from "../errors/index.js";
+import { ApprovalErrorCode } from "./error-codes.js";
+class ApprovalError {
+  /**
+   * Create an error for invalid approval request
+   */
+  static invalidRequest(reason, context) {
+    return new DextoRuntimeError(
+      ApprovalErrorCode.APPROVAL_INVALID_REQUEST,
+      ErrorScope.TOOLS,
+      // Approvals are part of tool execution flow
+      ErrorType.USER,
+      `Invalid approval request: ${reason}`,
+      context,
+      ["Check the approval request structure", "Ensure all required fields are provided"]
+    );
+  }
+  /**
+   * Create an error for invalid approval response
+   */
+  static invalidResponse(reason, context) {
+    return new DextoRuntimeError(
+      ApprovalErrorCode.APPROVAL_INVALID_RESPONSE,
+      ErrorScope.TOOLS,
+      ErrorType.USER,
+      `Invalid approval response: ${reason}`,
+      context,
+      [
+        "Check the approval response structure",
+        "Ensure approvalId matches the request",
+        "Verify status is valid"
+      ]
+    );
+  }
+  /**
+   * Create an error for invalid metadata
+   */
+  static invalidMetadata(type, reason) {
+    return new DextoRuntimeError(
+      ApprovalErrorCode.APPROVAL_INVALID_METADATA,
+      ErrorScope.TOOLS,
+      ErrorType.USER,
+      `Invalid metadata for ${type}: ${reason}`,
+      { type, reason },
+      ["Check the metadata structure for this approval type"]
+    );
+  }
+  /**
+   * Create an error for invalid elicitation schema
+   */
+  static invalidSchema(reason) {
+    return new DextoRuntimeError(
+      ApprovalErrorCode.APPROVAL_INVALID_SCHEMA,
+      ErrorScope.TOOLS,
+      ErrorType.USER,
+      `Invalid elicitation schema: ${reason}`,
+      { reason },
+      ["Ensure the schema is a valid JSON Schema", "Check MCP server implementation"]
+    );
+  }
+  /**
+   * Create an error for approval timeout
+   */
+  static timeout(approvalId, type, timeout, sessionId) {
+    const context = {
+      approvalId,
+      type,
+      timeout
+    };
+    if (sessionId !== void 0) {
+      context.sessionId = sessionId;
+    }
+    return new DextoRuntimeError(
+      ApprovalErrorCode.APPROVAL_TIMEOUT,
+      ErrorScope.TOOLS,
+      ErrorType.TIMEOUT,
+      `Approval request timed out after ${timeout}ms`,
+      context,
+      [
+        "Increase the timeout value",
+        "Respond to approval requests more quickly",
+        "Check if approval UI is functioning"
+      ]
+    );
+  }
+  /**
+   * Create an error for cancelled approval
+   */
+  static cancelled(approvalId, type, reason) {
+    const message = reason ? `Approval request cancelled: ${reason}` : "Approval request was cancelled";
+    const context = {
+      approvalId,
+      type
+    };
+    if (reason !== void 0) {
+      context.reason = reason;
+    }
+    return new DextoRuntimeError(
+      ApprovalErrorCode.APPROVAL_CANCELLED,
+      ErrorScope.TOOLS,
+      ErrorType.USER,
+      message,
+      context
+    );
+  }
+  /**
+   * Create an error for all approvals cancelled
+   */
+  static cancelledAll(reason) {
+    const message = reason ? `All approval requests cancelled: ${reason}` : "All approval requests were cancelled";
+    const context = {};
+    if (reason !== void 0) {
+      context.reason = reason;
+    }
+    return new DextoRuntimeError(
+      ApprovalErrorCode.APPROVAL_CANCELLED_ALL,
+      ErrorScope.TOOLS,
+      ErrorType.USER,
+      message,
+      context
+    );
+  }
+  /**
+   * Create an error for approval provider not configured
+   */
+  static providerNotConfigured() {
+    return new DextoRuntimeError(
+      ApprovalErrorCode.APPROVAL_PROVIDER_NOT_CONFIGURED,
+      ErrorScope.TOOLS,
+      ErrorType.SYSTEM,
+      "Approval provider not configured",
+      {},
+      [
+        "Configure an approval provider in your agent configuration",
+        "Check approval.mode in agent.yml"
+      ]
+    );
+  }
+  /**
+   * Create an error for approval provider error
+   */
+  static providerError(message, cause) {
+    const context = {};
+    if (cause?.message !== void 0) {
+      context.cause = cause.message;
+    }
+    return new DextoRuntimeError(
+      ApprovalErrorCode.APPROVAL_PROVIDER_ERROR,
+      ErrorScope.TOOLS,
+      ErrorType.SYSTEM,
+      `Approval provider error: ${message}`,
+      context,
+      ["Check approval provider implementation", "Review system logs for details"]
+    );
+  }
+  /**
+   * Create an error for approval not found
+   */
+  static notFound(approvalId) {
+    return new DextoRuntimeError(
+      ApprovalErrorCode.APPROVAL_NOT_FOUND,
+      ErrorScope.TOOLS,
+      ErrorType.NOT_FOUND,
+      `Approval request not found: ${approvalId}`,
+      { approvalId },
+      [
+        "Verify the approvalId is correct",
+        "Check if the approval has already been resolved or timed out"
+      ]
+    );
+  }
+  /**
+   * Create an error for tool confirmation denied
+   */
+  static toolConfirmationDenied(toolName, sessionId) {
+    return new DextoRuntimeError(
+      ApprovalErrorCode.APPROVAL_TOOL_CONFIRMATION_DENIED,
+      ErrorScope.TOOLS,
+      ErrorType.FORBIDDEN,
+      `Tool execution denied: ${toolName}`,
+      sessionId ? { toolName, sessionId } : { toolName },
+      ["Approve the tool in the confirmation dialog", "Check tool permissions"]
+    );
+  }
+  /**
+   * Create an error for elicitation denied
+   */
+  static elicitationDenied(serverName, sessionId) {
+    return new DextoRuntimeError(
+      ApprovalErrorCode.APPROVAL_ELICITATION_DENIED,
+      ErrorScope.TOOLS,
+      ErrorType.FORBIDDEN,
+      `Elicitation request denied from MCP server: ${serverName}`,
+      sessionId ? { serverName, sessionId } : { serverName },
+      ["Complete the requested form", "Check MCP server requirements"]
+    );
+  }
+  /**
+   * Create an error for elicitation validation failed
+   */
+  static elicitationValidationFailed(serverName, errors, approvalId) {
+    return new DextoRuntimeError(
+      ApprovalErrorCode.APPROVAL_ELICITATION_VALIDATION_FAILED,
+      ErrorScope.TOOLS,
+      ErrorType.USER,
+      `Elicitation form validation failed: ${errors.join(", ")}`,
+      { approvalId, serverName, errors },
+      ["Check the form inputs match the schema requirements", "Review validation errors"]
+    );
+  }
+  /**
+   * Create an error for invalid approval configuration
+   */
+  static invalidConfig(reason) {
+    return new DextoRuntimeError(
+      ApprovalErrorCode.APPROVAL_CONFIG_INVALID,
+      ErrorScope.TOOLS,
+      ErrorType.USER,
+      `Invalid approval configuration: ${reason}`,
+      { reason },
+      ["Check approval configuration in agent.yml", "Review approval.mode and related fields"]
+    );
+  }
+}
+export {
+  ApprovalError
+};

package/dist/approval/index.cjs

@@ -0,0 +1,84 @@
+"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 approval_exports = {};
+__export(approval_exports, {
+  ApprovalError: () => import_errors.ApprovalError,
+  ApprovalErrorCode: () => import_error_codes.ApprovalErrorCode,
+  ApprovalManager: () => import_manager.ApprovalManager,
+  ApprovalRequestDetailsSchema: () => import_schemas.ApprovalRequestDetailsSchema,
+  ApprovalRequestSchema: () => import_schemas.ApprovalRequestSchema,
+  ApprovalResponseSchema: () => import_schemas.ApprovalResponseSchema,
+  ApprovalStatus: () => import_types.ApprovalStatus,
+  ApprovalStatusSchema: () => import_schemas.ApprovalStatusSchema,
+  ApprovalType: () => import_types.ApprovalType,
+  ApprovalTypeSchema: () => import_schemas.ApprovalTypeSchema,
+  BaseApprovalRequestSchema: () => import_schemas.BaseApprovalRequestSchema,
+  BaseApprovalResponseSchema: () => import_schemas.BaseApprovalResponseSchema,
+  CustomApprovalMetadataSchema: () => import_schemas.CustomApprovalMetadataSchema,
+  CustomApprovalRequestSchema: () => import_schemas.CustomApprovalRequestSchema,
+  CustomApprovalResponseDataSchema: () => import_schemas.CustomApprovalResponseDataSchema,
+  CustomApprovalResponseSchema: () => import_schemas.CustomApprovalResponseSchema,
+  ElicitationMetadataSchema: () => import_schemas.ElicitationMetadataSchema,
+  ElicitationRequestSchema: () => import_schemas.ElicitationRequestSchema,
+  ElicitationResponseDataSchema: () => import_schemas.ElicitationResponseDataSchema,
+  ElicitationResponseSchema: () => import_schemas.ElicitationResponseSchema,
+  EventBasedApprovalProvider: () => import_event_based_approval_provider.EventBasedApprovalProvider,
+  NoOpApprovalProvider: () => import_noop_approval_provider.NoOpApprovalProvider,
+  ToolConfirmationMetadataSchema: () => import_schemas.ToolConfirmationMetadataSchema,
+  ToolConfirmationRequestSchema: () => import_schemas.ToolConfirmationRequestSchema,
+  ToolConfirmationResponseDataSchema: () => import_schemas.ToolConfirmationResponseDataSchema,
+  ToolConfirmationResponseSchema: () => import_schemas.ToolConfirmationResponseSchema
+});
+module.exports = __toCommonJS(approval_exports);
+var import_types = require("./types.js");
+var import_schemas = require("./schemas.js");
+var import_error_codes = require("./error-codes.js");
+var import_errors = require("./errors.js");
+var import_manager = require("./manager.js");
+var import_event_based_approval_provider = require("./providers/event-based-approval-provider.js");
+var import_noop_approval_provider = require("./providers/noop-approval-provider.js");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApprovalError,
+  ApprovalErrorCode,
+  ApprovalManager,
+  ApprovalRequestDetailsSchema,
+  ApprovalRequestSchema,
+  ApprovalResponseSchema,
+  ApprovalStatus,
+  ApprovalStatusSchema,
+  ApprovalType,
+  ApprovalTypeSchema,
+  BaseApprovalRequestSchema,
+  BaseApprovalResponseSchema,
+  CustomApprovalMetadataSchema,
+  CustomApprovalRequestSchema,
+  CustomApprovalResponseDataSchema,
+  CustomApprovalResponseSchema,
+  ElicitationMetadataSchema,
+  ElicitationRequestSchema,
+  ElicitationResponseDataSchema,
+  ElicitationResponseSchema,
+  EventBasedApprovalProvider,
+  NoOpApprovalProvider,
+  ToolConfirmationMetadataSchema,
+  ToolConfirmationRequestSchema,
+  ToolConfirmationResponseDataSchema,
+  ToolConfirmationResponseSchema
+});

package/dist/approval/index.d.ts

@@ -0,0 +1,12 @@
+export type { ApprovalProvider, ApprovalRequest, ApprovalResponse, ApprovalRequestDetails, ElicitationMetadata, ElicitationRequest, ElicitationResponse, ElicitationResponseData, CustomApprovalMetadata, CustomApprovalRequest, CustomApprovalResponse, CustomApprovalResponseData, BaseApprovalRequest, BaseApprovalResponse, } from './types.js';
+export { ApprovalType, ApprovalStatus } from './types.js';
+export { ApprovalTypeSchema, ApprovalStatusSchema, ToolConfirmationMetadataSchema, ElicitationMetadataSchema, CustomApprovalMetadataSchema, BaseApprovalRequestSchema, ToolConfirmationRequestSchema, ElicitationRequestSchema, CustomApprovalRequestSchema, ApprovalRequestSchema, ToolConfirmationResponseDataSchema, ElicitationResponseDataSchema, CustomApprovalResponseDataSchema, BaseApprovalResponseSchema, ToolConfirmationResponseSchema, ElicitationResponseSchema, CustomApprovalResponseSchema, ApprovalResponseSchema, ApprovalRequestDetailsSchema, } from './schemas.js';
+export type { ValidatedApprovalRequest, ValidatedApprovalResponse, ValidatedToolConfirmationRequest, ValidatedElicitationRequest, ValidatedCustomApprovalRequest, } from './schemas.js';
+export { ApprovalErrorCode } from './error-codes.js';
+export { ApprovalError } from './errors.js';
+export type { ApprovalValidationContext, ApprovalTimeoutContext, ApprovalCancellationContext, ElicitationValidationContext, } from './errors.js';
+export { ApprovalManager } from './manager.js';
+export type { ApprovalManagerConfig } from './manager.js';
+export { EventBasedApprovalProvider } from './providers/event-based-approval-provider.js';
+export { NoOpApprovalProvider } from './providers/noop-approval-provider.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/approval/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/approval/index.ts"],"names":[],"mappings":"AAKA,YAAY,EACR,gBAAgB,EAChB,eAAe,EACf,gBAAgB,EAChB,sBAAsB,EACtB,mBAAmB,EACnB,kBAAkB,EAClB,mBAAmB,EACnB,uBAAuB,EACvB,sBAAsB,EACtB,qBAAqB,EACrB,sBAAsB,EACtB,0BAA0B,EAC1B,mBAAmB,EACnB,oBAAoB,GACvB,MAAM,YAAY,CAAC;AAKpB,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAG1D,OAAO,EACH,kBAAkB,EAClB,oBAAoB,EACpB,8BAA8B,EAC9B,yBAAyB,EACzB,4BAA4B,EAC5B,yBAAyB,EACzB,6BAA6B,EAC7B,wBAAwB,EACxB,2BAA2B,EAC3B,qBAAqB,EACrB,kCAAkC,EAClC,6BAA6B,EAC7B,gCAAgC,EAChC,0BAA0B,EAC1B,8BAA8B,EAC9B,yBAAyB,EACzB,4BAA4B,EAC5B,sBAAsB,EACtB,4BAA4B,GAC/B,MAAM,cAAc,CAAC;AAEtB,YAAY,EACR,wBAAwB,EACxB,yBAAyB,EACzB,gCAAgC,EAChC,2BAA2B,EAC3B,8BAA8B,GACjC,MAAM,cAAc,CAAC;AAGtB,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,YAAY,EACR,yBAAyB,EACzB,sBAAsB,EACtB,2BAA2B,EAC3B,4BAA4B,GAC/B,MAAM,aAAa,CAAC;AAGrB,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAC/C,YAAY,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAG1D,OAAO,EAAE,0BAA0B,EAAE,MAAM,8CAA8C,CAAC;AAC1F,OAAO,EAAE,oBAAoB,EAAE,MAAM,uCAAuC,CAAC"}

package/dist/approval/index.js

@@ -0,0 +1,56 @@
+import "../chunk-C6A6W6XS.js";
+import { ApprovalType, ApprovalStatus } from "./types.js";
+import {
+  ApprovalTypeSchema,
+  ApprovalStatusSchema,
+  ToolConfirmationMetadataSchema,
+  ElicitationMetadataSchema,
+  CustomApprovalMetadataSchema,
+  BaseApprovalRequestSchema,
+  ToolConfirmationRequestSchema,
+  ElicitationRequestSchema,
+  CustomApprovalRequestSchema,
+  ApprovalRequestSchema,
+  ToolConfirmationResponseDataSchema,
+  ElicitationResponseDataSchema,
+  CustomApprovalResponseDataSchema,
+  BaseApprovalResponseSchema,
+  ToolConfirmationResponseSchema,
+  ElicitationResponseSchema,
+  CustomApprovalResponseSchema,
+  ApprovalResponseSchema,
+  ApprovalRequestDetailsSchema
+} from "./schemas.js";
+import { ApprovalErrorCode } from "./error-codes.js";
+import { ApprovalError } from "./errors.js";
+import { ApprovalManager } from "./manager.js";
+import { EventBasedApprovalProvider } from "./providers/event-based-approval-provider.js";
+import { NoOpApprovalProvider } from "./providers/noop-approval-provider.js";
+export {
+  ApprovalError,
+  ApprovalErrorCode,
+  ApprovalManager,
+  ApprovalRequestDetailsSchema,
+  ApprovalRequestSchema,
+  ApprovalResponseSchema,
+  ApprovalStatus,
+  ApprovalStatusSchema,
+  ApprovalType,
+  ApprovalTypeSchema,
+  BaseApprovalRequestSchema,
+  BaseApprovalResponseSchema,
+  CustomApprovalMetadataSchema,
+  CustomApprovalRequestSchema,
+  CustomApprovalResponseDataSchema,
+  CustomApprovalResponseSchema,
+  ElicitationMetadataSchema,
+  ElicitationRequestSchema,
+  ElicitationResponseDataSchema,
+  ElicitationResponseSchema,
+  EventBasedApprovalProvider,
+  NoOpApprovalProvider,
+  ToolConfirmationMetadataSchema,
+  ToolConfirmationRequestSchema,
+  ToolConfirmationResponseDataSchema,
+  ToolConfirmationResponseSchema
+};

package/dist/approval/manager.cjs

@@ -0,0 +1,189 @@
+"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 manager_exports = {};
+__export(manager_exports, {
+  ApprovalManager: () => ApprovalManager
+});
+module.exports = __toCommonJS(manager_exports);
+var import_types = require("./types.js");
+var import_event_based_approval_provider = require("./providers/event-based-approval-provider.js");
+var import_noop_approval_provider = require("./providers/noop-approval-provider.js");
+var import_factory = require("./providers/factory.js");
+var import_logger = require("../logger/index.js");
+var import_errors = require("./errors.js");
+class ApprovalManager {
+  provider;
+  config;
+  constructor(agentEventBus, config) {
+    this.config = config;
+    this.provider = this.createProvider(agentEventBus, config);
+    import_logger.logger.debug(
+      `ApprovalManager initialized with mode: ${config.mode}, timeout: ${config.timeout}ms`
+    );
+  }
+  /**
+   * Create appropriate approval provider based on configuration
+   * TODO: Move this into factory.ts
+   */
+  createProvider(agentEventBus, config) {
+    switch (config.mode) {
+      case "event-based":
+        return new import_event_based_approval_provider.EventBasedApprovalProvider(agentEventBus, {
+          defaultTimeout: config.timeout
+        });
+      case "auto-approve":
+        return new import_noop_approval_provider.NoOpApprovalProvider({ defaultStatus: import_types.ApprovalStatus.APPROVED });
+      case "auto-deny":
+        return new import_noop_approval_provider.NoOpApprovalProvider({ defaultStatus: import_types.ApprovalStatus.DENIED });
+      default:
+        throw import_errors.ApprovalError.invalidConfig(`Unknown approval mode: ${config.mode}`);
+    }
+  }
+  /**
+   * Request a generic approval
+   */
+  async requestApproval(details) {
+    const request = (0, import_factory.createApprovalRequest)(details);
+    return this.provider.requestApproval(request);
+  }
+  /**
+   * Request tool confirmation approval
+   * Convenience method for tool execution confirmation
+   */
+  async requestToolConfirmation(metadata) {
+    const { sessionId, timeout, ...toolMetadata } = metadata;
+    const details = {
+      type: import_types.ApprovalType.TOOL_CONFIRMATION,
+      timeout: timeout ?? this.config.timeout,
+      metadata: toolMetadata
+    };
+    if (sessionId !== void 0) {
+      details.sessionId = sessionId;
+    }
+    return this.requestApproval(details);
+  }
+  /**
+   * Request command confirmation approval
+   * Convenience method for dangerous command execution within an already-approved tool
+   *
+   * This is different from tool confirmation - it's for per-command approval
+   * of dangerous operations (like rm, git push) within tools that are already approved.
+   *
+   * @example
+   * ```typescript
+   * // bash_exec tool is approved, but dangerous commands still require approval
+   * const response = await manager.requestCommandConfirmation({
+   *   toolName: 'bash_exec',
+   *   command: 'rm -rf /important',
+   *   originalCommand: 'rm -rf /important',
+   *   sessionId: 'session-123'
+   * });
+   * ```
+   */
+  async requestCommandConfirmation(metadata) {
+    const { sessionId, timeout, ...commandMetadata } = metadata;
+    const details = {
+      type: import_types.ApprovalType.COMMAND_CONFIRMATION,
+      timeout: timeout ?? this.config.timeout,
+      metadata: commandMetadata
+    };
+    if (sessionId !== void 0) {
+      details.sessionId = sessionId;
+    }
+    return this.requestApproval(details);
+  }
+  /**
+   * Request elicitation from MCP server
+   * Convenience method for MCP elicitation requests
+   *
+   * Note: sessionId is optional because MCP servers are shared across sessions
+   * and the MCP protocol doesn't include session context in elicitation requests.
+   */
+  async requestElicitation(metadata) {
+    const { sessionId, timeout, ...elicitationMetadata } = metadata;
+    const details = {
+      type: import_types.ApprovalType.ELICITATION,
+      timeout: timeout ?? this.config.timeout,
+      metadata: elicitationMetadata
+    };
+    if (sessionId !== void 0) {
+      details.sessionId = sessionId;
+    }
+    return this.requestApproval(details);
+  }
+  /**
+   * Check if tool confirmation was approved
+   * Throws appropriate error if denied
+   */
+  async checkToolConfirmation(metadata) {
+    const response = await this.requestToolConfirmation(metadata);
+    if (response.status === import_types.ApprovalStatus.APPROVED) {
+      return true;
+    } else if (response.status === import_types.ApprovalStatus.DENIED) {
+      throw import_errors.ApprovalError.toolConfirmationDenied(metadata.toolName, metadata.sessionId);
+    } else {
+      throw import_errors.ApprovalError.cancelled(response.approvalId, import_types.ApprovalType.TOOL_CONFIRMATION);
+    }
+  }
+  /**
+   * Get elicitation form data
+   * Throws appropriate error if denied or cancelled
+   */
+  async getElicitationData(metadata) {
+    const response = await this.requestElicitation(metadata);
+    if (response.status === import_types.ApprovalStatus.APPROVED) {
+      if (response.data && typeof response.data === "object" && "formData" in response.data && typeof response.data.formData === "object" && response.data.formData !== null) {
+        return response.data.formData;
+      }
+      return {};
+    } else if (response.status === import_types.ApprovalStatus.DENIED) {
+      throw import_errors.ApprovalError.elicitationDenied(metadata.serverName, metadata.sessionId);
+    } else {
+      throw import_errors.ApprovalError.cancelled(response.approvalId, import_types.ApprovalType.ELICITATION);
+    }
+  }
+  /**
+   * Cancel a specific approval request
+   */
+  cancelApproval(approvalId) {
+    this.provider.cancelApproval(approvalId);
+  }
+  /**
+   * Cancel all pending approval requests
+   */
+  cancelAllApprovals() {
+    this.provider.cancelAllApprovals();
+  }
+  /**
+   * Get list of pending approval IDs
+   */
+  getPendingApprovals() {
+    return this.provider.getPendingApprovals();
+  }
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApprovalManager
+});