@dexto/core 1.1.10 → 1.1.11

package/dist/approval/manager.js

@@ -0,0 +1,135 @@
+import { ApprovalType, ApprovalStatus } from "./types.js";
+import { EventBasedApprovalProvider } from "./providers/event-based-approval-provider.js";
+import { NoOpApprovalProvider } from "./providers/noop-approval-provider.js";
+import { createApprovalRequest } from "./providers/factory.js";
+import { logger } from "../logger/index.js";
+import { ApprovalError } from "./errors.js";
+class ApprovalManager {
+  provider;
+  config;
+  constructor(agentEventBus, config) {
+    this.config = config;
+    this.provider = this.createProvider(agentEventBus, config);
+    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 EventBasedApprovalProvider(agentEventBus, {
+          defaultTimeout: config.timeout
+        });
+      case "auto-approve":
+        return new NoOpApprovalProvider({ defaultStatus: ApprovalStatus.APPROVED });
+      case "auto-deny":
+        return new NoOpApprovalProvider({ defaultStatus: ApprovalStatus.DENIED });
+      default:
+        throw ApprovalError.invalidConfig(`Unknown approval mode: ${config.mode}`);
+    }
+  }
+  /**
+   * Request a generic approval
+   */
+  async requestApproval(details) {
+    const request = 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: ApprovalType.TOOL_CONFIRMATION,
+      timeout: timeout ?? this.config.timeout,
+      metadata: toolMetadata
+    };
+    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: 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 === ApprovalStatus.APPROVED) {
+      return true;
+    } else if (response.status === ApprovalStatus.DENIED) {
+      throw ApprovalError.toolConfirmationDenied(metadata.toolName, metadata.sessionId);
+    } else {
+      throw ApprovalError.cancelled(response.approvalId, 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 === 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 === ApprovalStatus.DENIED) {
+      throw ApprovalError.elicitationDenied(metadata.serverName, metadata.sessionId);
+    } else {
+      throw ApprovalError.cancelled(response.approvalId, 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 };
+  }
+}
+export {
+  ApprovalManager
+};

package/dist/approval/providers/event-based-approval-provider.cjs

@@ -0,0 +1,156 @@
+"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 event_based_approval_provider_exports = {};
+__export(event_based_approval_provider_exports, {
+  EventBasedApprovalProvider: () => EventBasedApprovalProvider
+});
+module.exports = __toCommonJS(event_based_approval_provider_exports);
+var import_types = require("../types.js");
+var import_logger = require("../../logger/index.js");
+var import_errors = require("../errors.js");
+class EventBasedApprovalProvider {
+  pendingApprovals = /* @__PURE__ */ new Map();
+  defaultTimeout;
+  agentEventBus;
+  constructor(agentEventBus, options) {
+    this.agentEventBus = agentEventBus;
+    this.defaultTimeout = options.defaultTimeout;
+    this.agentEventBus.on("dexto:approvalResponse", this.handleApprovalResponse.bind(this));
+  }
+  /**
+   * Create and submit an approval request
+   */
+  async requestApproval(request) {
+    const timeout = request.timeout ?? this.defaultTimeout;
+    import_logger.logger.info(
+      `Approval request '${request.type}' created, approvalId: ${request.approvalId}, sessionId: ${request.sessionId ?? "global"}`
+    );
+    return new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        const timeoutResponse = request.sessionId ? {
+          approvalId: request.approvalId,
+          status: import_types.ApprovalStatus.CANCELLED,
+          sessionId: request.sessionId
+        } : {
+          approvalId: request.approvalId,
+          status: import_types.ApprovalStatus.CANCELLED
+        };
+        import_logger.logger.warn(
+          `Approval request timeout for '${request.type}', approvalId: ${request.approvalId}`
+        );
+        this.pendingApprovals.delete(request.approvalId);
+        this.agentEventBus.emit("dexto:approvalResponse", timeoutResponse);
+        reject(
+          import_errors.ApprovalError.timeout(
+            request.approvalId,
+            request.type,
+            timeout,
+            request.sessionId
+          )
+        );
+      }, timeout);
+      this.pendingApprovals.set(request.approvalId, {
+        resolve: (response) => {
+          clearTimeout(timeoutId);
+          this.pendingApprovals.delete(request.approvalId);
+          resolve(response);
+        },
+        reject: (error) => {
+          clearTimeout(timeoutId);
+          this.pendingApprovals.delete(request.approvalId);
+          reject(error);
+        },
+        request
+      });
+      const eventPayload = {
+        approvalId: request.approvalId,
+        type: request.type,
+        timestamp: request.timestamp,
+        metadata: request.metadata
+      };
+      if (request.sessionId !== void 0) {
+        eventPayload.sessionId = request.sessionId;
+      }
+      if (request.timeout !== void 0) {
+        eventPayload.timeout = request.timeout;
+      }
+      this.agentEventBus.emit("dexto:approvalRequest", eventPayload);
+    });
+  }
+  /**
+   * Handle approval response from external handlers
+   */
+  async handleApprovalResponse(response) {
+    const pending = this.pendingApprovals.get(response.approvalId);
+    if (!pending) {
+      import_logger.logger.warn(`Received approvalResponse for unknown approvalId ${response.approvalId}`);
+      return;
+    }
+    this.pendingApprovals.delete(response.approvalId);
+    import_logger.logger.info(
+      `Approval '${pending.request.type}' ${response.status}, approvalId: ${response.approvalId}, sessionId: ${response.sessionId ?? "global"}`
+    );
+    pending.resolve(response);
+  }
+  /**
+   * Cancel a pending approval request
+   */
+  cancelApproval(approvalId) {
+    const pending = this.pendingApprovals.get(approvalId);
+    if (pending) {
+      pending.reject(
+        import_errors.ApprovalError.cancelled(
+          approvalId,
+          pending.request.type,
+          "individual request cancelled"
+        )
+      );
+      this.pendingApprovals.delete(approvalId);
+      this.agentEventBus.emit("dexto:approvalResponse", {
+        approvalId,
+        status: import_types.ApprovalStatus.CANCELLED,
+        sessionId: pending.request.sessionId
+      });
+    }
+  }
+  /**
+   * Cancel all pending approval requests
+   */
+  cancelAllApprovals() {
+    for (const [approvalId, pending] of this.pendingApprovals) {
+      pending.reject(import_errors.ApprovalError.cancelledAll("all requests cancelled"));
+      this.agentEventBus.emit("dexto:approvalResponse", {
+        approvalId,
+        status: import_types.ApprovalStatus.CANCELLED,
+        sessionId: pending.request.sessionId
+      });
+    }
+    this.pendingApprovals.clear();
+  }
+  /**
+   * Get list of pending approval request IDs
+   */
+  getPendingApprovals() {
+    return Array.from(this.pendingApprovals.keys());
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EventBasedApprovalProvider
+});

package/dist/approval/providers/event-based-approval-provider.d.ts

@@ -0,0 +1,39 @@
+import type { ApprovalProvider, ApprovalRequest, ApprovalResponse } from '../types.js';
+import type { AgentEventBus } from '../../events/index.js';
+/**
+ * Event-based approval provider that uses the AgentEventBus to emit
+ * approval requests and wait for responses from UI layers.
+ *
+ * This provider decouples the core approval logic from UI implementations,
+ * allowing any client (CLI, WebUI, custom frontends) to handle approvals
+ * by listening to events and responding accordingly.
+ */
+export declare class EventBasedApprovalProvider implements ApprovalProvider {
+    private pendingApprovals;
+    private defaultTimeout;
+    private agentEventBus;
+    constructor(agentEventBus: AgentEventBus, options: {
+        defaultTimeout: number;
+    });
+    /**
+     * Create and submit an approval request
+     */
+    requestApproval(request: ApprovalRequest): Promise<ApprovalResponse>;
+    /**
+     * Handle approval response from external handlers
+     */
+    private handleApprovalResponse;
+    /**
+     * Cancel a pending approval request
+     */
+    cancelApproval(approvalId: string): void;
+    /**
+     * Cancel all pending approval requests
+     */
+    cancelAllApprovals(): void;
+    /**
+     * Get list of pending approval request IDs
+     */
+    getPendingApprovals(): string[];
+}
+//# sourceMappingURL=event-based-approval-provider.d.ts.map

package/dist/approval/providers/event-based-approval-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-based-approval-provider.d.ts","sourceRoot":"","sources":["../../../src/approval/providers/event-based-approval-provider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAEvF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAI3D;;;;;;;GAOG;AACH,qBAAa,0BAA2B,YAAW,gBAAgB;IAC/D,OAAO,CAAC,gBAAgB,CAOpB;IACJ,OAAO,CAAC,cAAc,CAAS;IAC/B,OAAO,CAAC,aAAa,CAAgB;gBAGjC,aAAa,EAAE,aAAa,EAC5B,OAAO,EAAE;QACL,cAAc,EAAE,MAAM,CAAC;KAC1B;IASL;;OAEG;IACG,eAAe,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAmF1E;;OAEG;YACW,sBAAsB;IAiBpC;;OAEG;IACH,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IAqBxC;;OAEG;IACH,kBAAkB,IAAI,IAAI;IAc1B;;OAEG;IACH,mBAAmB,IAAI,MAAM,EAAE;CAGlC"}

package/dist/approval/providers/event-based-approval-provider.js

@@ -0,0 +1,132 @@
+import { ApprovalStatus } from "../types.js";
+import { logger } from "../../logger/index.js";
+import { ApprovalError } from "../errors.js";
+class EventBasedApprovalProvider {
+  pendingApprovals = /* @__PURE__ */ new Map();
+  defaultTimeout;
+  agentEventBus;
+  constructor(agentEventBus, options) {
+    this.agentEventBus = agentEventBus;
+    this.defaultTimeout = options.defaultTimeout;
+    this.agentEventBus.on("dexto:approvalResponse", this.handleApprovalResponse.bind(this));
+  }
+  /**
+   * Create and submit an approval request
+   */
+  async requestApproval(request) {
+    const timeout = request.timeout ?? this.defaultTimeout;
+    logger.info(
+      `Approval request '${request.type}' created, approvalId: ${request.approvalId}, sessionId: ${request.sessionId ?? "global"}`
+    );
+    return new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        const timeoutResponse = request.sessionId ? {
+          approvalId: request.approvalId,
+          status: ApprovalStatus.CANCELLED,
+          sessionId: request.sessionId
+        } : {
+          approvalId: request.approvalId,
+          status: ApprovalStatus.CANCELLED
+        };
+        logger.warn(
+          `Approval request timeout for '${request.type}', approvalId: ${request.approvalId}`
+        );
+        this.pendingApprovals.delete(request.approvalId);
+        this.agentEventBus.emit("dexto:approvalResponse", timeoutResponse);
+        reject(
+          ApprovalError.timeout(
+            request.approvalId,
+            request.type,
+            timeout,
+            request.sessionId
+          )
+        );
+      }, timeout);
+      this.pendingApprovals.set(request.approvalId, {
+        resolve: (response) => {
+          clearTimeout(timeoutId);
+          this.pendingApprovals.delete(request.approvalId);
+          resolve(response);
+        },
+        reject: (error) => {
+          clearTimeout(timeoutId);
+          this.pendingApprovals.delete(request.approvalId);
+          reject(error);
+        },
+        request
+      });
+      const eventPayload = {
+        approvalId: request.approvalId,
+        type: request.type,
+        timestamp: request.timestamp,
+        metadata: request.metadata
+      };
+      if (request.sessionId !== void 0) {
+        eventPayload.sessionId = request.sessionId;
+      }
+      if (request.timeout !== void 0) {
+        eventPayload.timeout = request.timeout;
+      }
+      this.agentEventBus.emit("dexto:approvalRequest", eventPayload);
+    });
+  }
+  /**
+   * Handle approval response from external handlers
+   */
+  async handleApprovalResponse(response) {
+    const pending = this.pendingApprovals.get(response.approvalId);
+    if (!pending) {
+      logger.warn(`Received approvalResponse for unknown approvalId ${response.approvalId}`);
+      return;
+    }
+    this.pendingApprovals.delete(response.approvalId);
+    logger.info(
+      `Approval '${pending.request.type}' ${response.status}, approvalId: ${response.approvalId}, sessionId: ${response.sessionId ?? "global"}`
+    );
+    pending.resolve(response);
+  }
+  /**
+   * Cancel a pending approval request
+   */
+  cancelApproval(approvalId) {
+    const pending = this.pendingApprovals.get(approvalId);
+    if (pending) {
+      pending.reject(
+        ApprovalError.cancelled(
+          approvalId,
+          pending.request.type,
+          "individual request cancelled"
+        )
+      );
+      this.pendingApprovals.delete(approvalId);
+      this.agentEventBus.emit("dexto:approvalResponse", {
+        approvalId,
+        status: ApprovalStatus.CANCELLED,
+        sessionId: pending.request.sessionId
+      });
+    }
+  }
+  /**
+   * Cancel all pending approval requests
+   */
+  cancelAllApprovals() {
+    for (const [approvalId, pending] of this.pendingApprovals) {
+      pending.reject(ApprovalError.cancelledAll("all requests cancelled"));
+      this.agentEventBus.emit("dexto:approvalResponse", {
+        approvalId,
+        status: ApprovalStatus.CANCELLED,
+        sessionId: pending.request.sessionId
+      });
+    }
+    this.pendingApprovals.clear();
+  }
+  /**
+   * Get list of pending approval request IDs
+   */
+  getPendingApprovals() {
+    return Array.from(this.pendingApprovals.keys());
+  }
+}
+export {
+  EventBasedApprovalProvider
+};

package/dist/approval/providers/factory.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 factory_exports = {};
+__export(factory_exports, {
+  createApprovalRequest: () => createApprovalRequest
+});
+module.exports = __toCommonJS(factory_exports);
+var import_crypto = require("crypto");
+function createApprovalRequest(details) {
+  return {
+    approvalId: (0, import_crypto.randomUUID)(),
+    type: details.type,
+    sessionId: details.sessionId,
+    timeout: details.timeout,
+    timestamp: /* @__PURE__ */ new Date(),
+    metadata: details.metadata
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createApprovalRequest
+});

package/dist/approval/providers/factory.d.ts

@@ -0,0 +1,12 @@
+import type { ApprovalRequest, ApprovalRequestDetails } from '../types.js';
+/**
+ * Factory function to create an approval request with generated ID and timestamp.
+ *
+ * This is a generic helper used by all approval providers to create properly
+ * formatted approval requests from simplified details.
+ *
+ * @param details - Simplified approval request details without ID and timestamp
+ * @returns A complete ApprovalRequest with generated UUID and current timestamp
+ */
+export declare function createApprovalRequest(details: ApprovalRequestDetails): ApprovalRequest;
+//# sourceMappingURL=factory.d.ts.map

package/dist/approval/providers/factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../src/approval/providers/factory.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAE3E;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,sBAAsB,GAAG,eAAe,CAStF"}

package/dist/approval/providers/factory.js

@@ -0,0 +1,14 @@
+import { randomUUID } from "crypto";
+function createApprovalRequest(details) {
+  return {
+    approvalId: randomUUID(),
+    type: details.type,
+    sessionId: details.sessionId,
+    timeout: details.timeout,
+    timestamp: /* @__PURE__ */ new Date(),
+    metadata: details.metadata
+  };
+}
+export {
+  createApprovalRequest
+};

package/dist/approval/providers/noop-approval-provider.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 noop_approval_provider_exports = {};
+__export(noop_approval_provider_exports, {
+  NoOpApprovalProvider: () => NoOpApprovalProvider
+});
+module.exports = __toCommonJS(noop_approval_provider_exports);
+var import_logger = require("../../logger/index.js");
+class NoOpApprovalProvider {
+  defaultStatus;
+  constructor(options) {
+    this.defaultStatus = options.defaultStatus;
+  }
+  async requestApproval(request) {
+    import_logger.logger.info(
+      `Auto-${this.defaultStatus} approval '${request.type}', approvalId: ${request.approvalId}`
+    );
+    const response = {
+      approvalId: request.approvalId,
+      status: this.defaultStatus
+    };
+    if (request.sessionId !== void 0) {
+      response.sessionId = request.sessionId;
+    }
+    return response;
+  }
+  cancelApproval(_approvalId) {
+  }
+  cancelAllApprovals() {
+  }
+  getPendingApprovals() {
+    return [];
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NoOpApprovalProvider
+});

package/dist/approval/providers/noop-approval-provider.d.ts

@@ -0,0 +1,18 @@
+import type { ApprovalProvider, ApprovalRequest, ApprovalResponse, ApprovalStatus } from '../types.js';
+/**
+ * No-op approval provider that automatically approves or denies all requests
+ * without user interaction.
+ *
+ * Used for auto-approve and auto-deny modes.
+ */
+export declare class NoOpApprovalProvider implements ApprovalProvider {
+    private defaultStatus;
+    constructor(options: {
+        defaultStatus: ApprovalStatus;
+    });
+    requestApproval(request: ApprovalRequest): Promise<ApprovalResponse>;
+    cancelApproval(_approvalId: string): void;
+    cancelAllApprovals(): void;
+    getPendingApprovals(): string[];
+}
+//# sourceMappingURL=noop-approval-provider.d.ts.map

package/dist/approval/providers/noop-approval-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"noop-approval-provider.d.ts","sourceRoot":"","sources":["../../../src/approval/providers/noop-approval-provider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACR,gBAAgB,EAChB,eAAe,EACf,gBAAgB,EAChB,cAAc,EACjB,MAAM,aAAa,CAAC;AAGrB;;;;;GAKG;AACH,qBAAa,oBAAqB,YAAW,gBAAgB;IACzD,OAAO,CAAC,aAAa,CAAiB;gBAE1B,OAAO,EAAE;QAAE,aAAa,EAAE,cAAc,CAAA;KAAE;IAIhD,eAAe,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAiB1E,cAAc,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI;IAIzC,kBAAkB,IAAI,IAAI;IAI1B,mBAAmB,IAAI,MAAM,EAAE;CAGlC"}

package/dist/approval/providers/noop-approval-provider.js

@@ -0,0 +1,30 @@
+import { logger } from "../../logger/index.js";
+class NoOpApprovalProvider {
+  defaultStatus;
+  constructor(options) {
+    this.defaultStatus = options.defaultStatus;
+  }
+  async requestApproval(request) {
+    logger.info(
+      `Auto-${this.defaultStatus} approval '${request.type}', approvalId: ${request.approvalId}`
+    );
+    const response = {
+      approvalId: request.approvalId,
+      status: this.defaultStatus
+    };
+    if (request.sessionId !== void 0) {
+      response.sessionId = request.sessionId;
+    }
+    return response;
+  }
+  cancelApproval(_approvalId) {
+  }
+  cancelAllApprovals() {
+  }
+  getPendingApprovals() {
+    return [];
+  }
+}
+export {
+  NoOpApprovalProvider
+};