@dexto/core 1.1.10 → 1.2.0

package/dist/approval/manager.d.ts

@@ -0,0 +1,131 @@
+import type { ApprovalResponse, ApprovalRequestDetails, ToolConfirmationMetadata, CommandConfirmationMetadata, ElicitationMetadata } from './types.js';
+import type { AgentEventBus } from '../events/index.js';
+/**
+ * Configuration for the approval manager
+ */
+export interface ApprovalManagerConfig {
+    mode: 'event-based' | 'auto-approve' | 'auto-deny';
+    /**
+     * Timeout in milliseconds for approval requests
+     * @default 120000 (2 minutes)
+     */
+    timeout: number;
+}
+/**
+ * ApprovalManager orchestrates all user approval flows in Dexto.
+ *
+ * It provides a unified interface for requesting user approvals across different
+ * types (tool confirmation, MCP elicitation, custom approvals) and manages the
+ * underlying approval provider based on configuration.
+ *
+ * Key responsibilities:
+ * - Create and submit approval requests
+ * - Route approvals to appropriate providers
+ * - Provide convenience methods for specific approval types
+ * - Handle approval responses and errors
+ * - Support multiple approval modes (event-based, auto-approve, auto-deny)
+ *
+ * @example
+ * ```typescript
+ * const manager = new ApprovalManager(eventBus, { mode: 'event-based' });
+ *
+ * // Request tool confirmation
+ * const response = await manager.requestToolConfirmation({
+ *   toolName: 'git_commit',
+ *   args: { message: 'feat: add feature' },
+ *   sessionId: 'session-123'
+ * });
+ *
+ * if (response.status === 'approved') {
+ *   // Execute tool
+ * }
+ * ```
+ */
+export declare class ApprovalManager {
+    private provider;
+    private config;
+    constructor(agentEventBus: AgentEventBus, config: ApprovalManagerConfig);
+    /**
+     * Create appropriate approval provider based on configuration
+     * TODO: Move this into factory.ts
+     */
+    private createProvider;
+    /**
+     * Request a generic approval
+     */
+    requestApproval(details: ApprovalRequestDetails): Promise<ApprovalResponse>;
+    /**
+     * Request tool confirmation approval
+     * Convenience method for tool execution confirmation
+     */
+    requestToolConfirmation(metadata: ToolConfirmationMetadata & {
+        sessionId?: string;
+        timeout?: number;
+    }): Promise<ApprovalResponse>;
+    /**
+     * 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'
+     * });
+     * ```
+     */
+    requestCommandConfirmation(metadata: CommandConfirmationMetadata & {
+        sessionId?: string;
+        timeout?: number;
+    }): Promise<ApprovalResponse>;
+    /**
+     * 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.
+     */
+    requestElicitation(metadata: ElicitationMetadata & {
+        sessionId?: string;
+        timeout?: number;
+    }): Promise<ApprovalResponse>;
+    /**
+     * Check if tool confirmation was approved
+     * Throws appropriate error if denied
+     */
+    checkToolConfirmation(metadata: ToolConfirmationMetadata & {
+        sessionId?: string;
+        timeout?: number;
+    }): Promise<boolean>;
+    /**
+     * Get elicitation form data
+     * Throws appropriate error if denied or cancelled
+     */
+    getElicitationData(metadata: ElicitationMetadata & {
+        sessionId?: string;
+        timeout?: number;
+    }): Promise<Record<string, unknown>>;
+    /**
+     * Cancel a specific approval request
+     */
+    cancelApproval(approvalId: string): void;
+    /**
+     * Cancel all pending approval requests
+     */
+    cancelAllApprovals(): void;
+    /**
+     * Get list of pending approval IDs
+     */
+    getPendingApprovals(): string[];
+    /**
+     * Get current configuration
+     */
+    getConfig(): ApprovalManagerConfig;
+}
+//# sourceMappingURL=manager.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"manager.d.ts","sourceRoot":"","sources":["../../src/approval/manager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAER,gBAAgB,EAChB,sBAAsB,EACtB,wBAAwB,EACxB,2BAA2B,EAC3B,mBAAmB,EACtB,MAAM,YAAY,CAAC;AAKpB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAIxD;;GAEG;AACH,MAAM,WAAW,qBAAqB;IAClC,IAAI,EAAE,aAAa,GAAG,cAAc,GAAG,WAAW,CAAC;IACnD;;;OAGG;IACH,OAAO,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,qBAAa,eAAe;IACxB,OAAO,CAAC,QAAQ,CAAmB;IACnC,OAAO,CAAC,MAAM,CAAwB;gBAE1B,aAAa,EAAE,aAAa,EAAE,MAAM,EAAE,qBAAqB;IASvE;;;OAGG;IACH,OAAO,CAAC,cAAc;IAkBtB;;OAEG;IACG,eAAe,CAAC,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAKjF;;;OAGG;IACG,uBAAuB,CACzB,QAAQ,EAAE,wBAAwB,GAAG;QAAE,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,GAC9E,OAAO,CAAC,gBAAgB,CAAC;IAgB5B;;;;;;;;;;;;;;;;;OAiBG;IACG,0BAA0B,CAC5B,QAAQ,EAAE,2BAA2B,GAAG;QAAE,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,GACjF,OAAO,CAAC,gBAAgB,CAAC;IAgB5B;;;;;;OAMG;IACG,kBAAkB,CACpB,QAAQ,EAAE,mBAAmB,GAAG;QAAE,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,GACzE,OAAO,CAAC,gBAAgB,CAAC;IAgB5B;;;OAGG;IACG,qBAAqB,CACvB,QAAQ,EAAE,wBAAwB,GAAG;QAAE,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,GAC9E,OAAO,CAAC,OAAO,CAAC;IAYnB;;;OAGG;IACG,kBAAkB,CACpB,QAAQ,EAAE,mBAAmB,GAAG;QAAE,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,GACzE,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAwBnC;;OAEG;IACH,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IAIxC;;OAEG;IACH,kBAAkB,IAAI,IAAI;IAI1B;;OAEG;IACH,mBAAmB,IAAI,MAAM,EAAE;IAI/B;;OAEG;IACH,SAAS,IAAI,qBAAqB;CAGrC"}

package/dist/approval/manager.js

@@ -0,0 +1,166 @@
+import "../chunk-C6A6W6XS.js";
+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 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: 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: 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,133 @@
+import "../../chunk-C6A6W6XS.js";
+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"}