@dexto/core 1.1.10 → 1.1.11

package/dist/systemPrompt/types.d.cts

@@ -1,19 +0,0 @@
-import { MCPManager } from '../mcp/manager.cjs';
-import '../mcp/schemas.cjs';
-import 'zod';
-import '../mcp/types.cjs';
-import '@modelcontextprotocol/sdk/client/index.js';
-import '../tools/types.cjs';
-import 'json-schema';
-import '@modelcontextprotocol/sdk/types.js';
-
-interface DynamicContributorContext {
-    mcpManager: MCPManager;
-}
-interface SystemPromptContributor {
-    id: string;
-    priority: number;
-    getContent(context: DynamicContributorContext): Promise<string>;
-}
-
-export type { DynamicContributorContext, SystemPromptContributor };

package/dist/tools/confirmation/allowed-tools-provider/factory.d.cts

@@ -1,19 +0,0 @@
-import { IAllowedToolsProvider } from './types.cjs';
-import { StorageBackends } from '../../../storage/backend/types.cjs';
-import '../../../storage/backend/cache-backend.cjs';
-import '../../../storage/backend/database-backend.cjs';
-import '../../../storage/schemas.cjs';
-import 'zod';
-
-type AllowedToolsConfig = {
-    type: 'memory';
-} | {
-    type: 'storage';
-    storage: StorageBackends;
-};
-/**
- * Create an AllowedToolsProvider based on configuration.
- */
-declare function createAllowedToolsProvider(config: AllowedToolsConfig): IAllowedToolsProvider;
-
-export { type AllowedToolsConfig, createAllowedToolsProvider };

package/dist/tools/confirmation/allowed-tools-provider/in-memory.d.cts

@@ -1,17 +0,0 @@
-import { IAllowedToolsProvider } from './types.cjs';
-
-declare class InMemoryAllowedToolsProvider implements IAllowedToolsProvider {
-    /**
-     * Map key is sessionId (undefined => global approvals). Value is a set of
-     * approved tool names.
-     */
-    private store;
-    constructor(initialGlobal?: Set<string>);
-    private getSet;
-    allowTool(toolName: string, sessionId?: string): Promise<void>;
-    disallowTool(toolName: string, sessionId?: string): Promise<void>;
-    isToolAllowed(toolName: string, sessionId?: string): Promise<boolean>;
-    getAllowedTools(sessionId?: string): Promise<Set<string>>;
-}
-
-export { InMemoryAllowedToolsProvider };

package/dist/tools/confirmation/allowed-tools-provider/storage.d.cts

@@ -1,26 +0,0 @@
-import { StorageBackends } from '../../../storage/backend/types.cjs';
-import { IAllowedToolsProvider } from './types.cjs';
-import '../../../storage/backend/cache-backend.cjs';
-import '../../../storage/backend/database-backend.cjs';
-import '../../../storage/schemas.cjs';
-import 'zod';
-
-/**
- * Storage-backed implementation that persists allowed tools in the Dexto
- * storage backends. The key scheme is:
- *   allowedTools:<sessionId>          – approvals scoped to a session
- *   allowedTools:global               – global approvals (sessionId undefined)
- *
- * Using the database backend for persistence.
- */
-declare class StorageAllowedToolsProvider implements IAllowedToolsProvider {
-    private storage;
-    constructor(storage: StorageBackends);
-    private buildKey;
-    allowTool(toolName: string, sessionId?: string): Promise<void>;
-    disallowTool(toolName: string, sessionId?: string): Promise<void>;
-    isToolAllowed(toolName: string, sessionId?: string): Promise<boolean>;
-    getAllowedTools(sessionId?: string): Promise<Set<string>>;
-}
-
-export { StorageAllowedToolsProvider };

package/dist/tools/confirmation/allowed-tools-provider/types.d.cts

@@ -1,35 +0,0 @@
-/**
- * Interface for allowed tools storage (in-memory, DB, etc.)
- *
- * Multi-user support: For multi-tenancy, we can consider either:
- *  - Instantiating a provider per user (current pattern, recommended for most cases)
- *  - Or, add userId as a parameter to each method for batch/admin/multi-user operations:
- *      allowTool(toolName: string, userId: string): Promise<void>
- *      ...etc.
- *  - You can also add static/factory methods to create user-scoped providers, e.g.,
- *      AllowedToolsProvider.forUser(userId)
- *
- * AllowedToolsProvider supports both single-user and multi-user scenarios.
- * - If `userId` is omitted, the implementation will use a default user (e.g., from getUserId()).
- * - For multi-user/admin scenarios, always pass `userId` explicitly.
- * - We can enforce this by having a separate env variable/feature-flag for multi-user and having
- *   strict check for the user id if the feature flag is set.
- */
-interface IAllowedToolsProvider {
-    /**
-     * Persist an approval for a tool. If `sessionId` is provided the approval is
-     * scoped to that session. When omitted the approval is treated as global.
-     */
-    allowTool(toolName: string, sessionId?: string): Promise<void>;
-    /** Remove an approval. */
-    disallowTool(toolName: string, sessionId?: string): Promise<void>;
-    /**
-     * Check whether the given tool is currently allowed. If `sessionId` is
-     * provided the session-scoped list is checked first, then any global entry.
-     */
-    isToolAllowed(toolName: string, sessionId?: string): Promise<boolean>;
-    /** Optional helper to introspect all approvals for debugging. */
-    getAllowedTools?(sessionId?: string): Promise<Set<string>>;
-}
-
-export type { IAllowedToolsProvider };

package/dist/tools/confirmation/event-based-confirmation-provider.cjs

@@ -1,158 +0,0 @@
-"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_confirmation_provider_exports = {};
-__export(event_based_confirmation_provider_exports, {
-  EventBasedConfirmationProvider: () => EventBasedConfirmationProvider
-});
-module.exports = __toCommonJS(event_based_confirmation_provider_exports);
-var import_crypto = require("crypto");
-var import_logger = require("../../logger/index.cjs");
-var import_errors = require("../errors.js");
-class EventBasedConfirmationProvider {
-  constructor(allowedToolsProvider, agentEventBus, options) {
-    this.allowedToolsProvider = allowedToolsProvider;
-    this.agentEventBus = agentEventBus;
-    this.confirmationTimeout = options.confirmationTimeout;
-    this.agentEventBus.on(
-      "dexto:toolConfirmationResponse",
-      this.handleConfirmationResponse.bind(this)
-    );
-  }
-  pendingConfirmations = /* @__PURE__ */ new Map();
-  confirmationTimeout;
-  agentEventBus;
-  async requestConfirmation(details) {
-    const isAllowed = await this.allowedToolsProvider.isToolAllowed(
-      details.toolName,
-      details.sessionId
-    );
-    if (isAllowed) {
-      import_logger.logger.info(
-        `Tool '${details.toolName}' already allowed for session '${details.sessionId ?? "global"}' \u2013 skipping confirmation.`
-      );
-      return true;
-    }
-    const executionId = (0, import_crypto.randomUUID)();
-    const event = {
-      toolName: details.toolName,
-      args: details.args,
-      ...details.description && { description: details.description },
-      executionId,
-      timestamp: /* @__PURE__ */ new Date(),
-      ...details.sessionId && { sessionId: details.sessionId }
-      // session context
-    };
-    import_logger.logger.info(
-      `Tool confirmation requested for ${details.toolName}, executionId: ${executionId}, sessionId: ${details.sessionId}`
-    );
-    return new Promise((resolve, reject) => {
-      const timeout = setTimeout(() => {
-        const timeoutResponse = {
-          executionId,
-          approved: false,
-          rememberChoice: false,
-          ...details.sessionId && { sessionId: details.sessionId }
-        };
-        import_logger.logger.warn(
-          `Tool confirmation timeout for ${details.toolName}, executionId: ${executionId}`
-        );
-        this.pendingConfirmations.delete(executionId);
-        this.agentEventBus.emit("dexto:toolConfirmationResponse", timeoutResponse);
-        reject(
-          import_errors.ToolError.confirmationTimeout(
-            details.toolName,
-            this.confirmationTimeout,
-            details.sessionId
-          )
-        );
-      }, this.confirmationTimeout);
-      this.pendingConfirmations.set(executionId, {
-        resolve: (approved) => {
-          clearTimeout(timeout);
-          this.pendingConfirmations.delete(executionId);
-          resolve(approved);
-        },
-        reject: (error) => {
-          clearTimeout(timeout);
-          this.pendingConfirmations.delete(executionId);
-          reject(error);
-        },
-        toolName: details.toolName,
-        ...details.sessionId && { sessionId: details.sessionId }
-      });
-      this.agentEventBus.emit("dexto:toolConfirmationRequest", event);
-    });
-  }
-  /**
-   * Handle confirmation response from external handlers
-   */
-  async handleConfirmationResponse(response) {
-    const pending = this.pendingConfirmations.get(response.executionId);
-    if (!pending) {
-      import_logger.logger.warn(
-        `Received toolConfirmationResponse for unknown executionId ${response.executionId}`
-      );
-      return;
-    }
-    this.pendingConfirmations.delete(response.executionId);
-    if (response.approved && response.rememberChoice) {
-      await this.allowedToolsProvider.allowTool(pending.toolName, response.sessionId);
-      import_logger.logger.info(
-        `Tool '${pending.toolName}' added to allowed tools for session '${response.sessionId ?? "global"}' (remember choice selected)`
-      );
-    }
-    import_logger.logger.info(
-      `Tool confirmation ${response.approved ? "approved" : "denied"} for ${pending.toolName}, executionId: ${response.executionId}, sessionId: ${response.sessionId ?? "global"}`
-    );
-    pending.resolve(response.approved);
-  }
-  /**
-   * Get list of pending confirmation requests
-   */
-  getPendingConfirmations() {
-    return Array.from(this.pendingConfirmations.keys());
-  }
-  /**
-   * Cancel a pending confirmation request
-   */
-  cancelConfirmation(executionId) {
-    const pending = this.pendingConfirmations.get(executionId);
-    if (pending) {
-      pending.reject(
-        import_errors.ToolError.confirmationCancelled(pending.toolName, "individual request cancelled")
-      );
-      this.pendingConfirmations.delete(executionId);
-    }
-  }
-  /**
-   * Cancel all pending confirmation requests
-   */
-  cancelAllConfirmations() {
-    for (const [_executionId, pending] of this.pendingConfirmations) {
-      pending.reject(
-        import_errors.ToolError.confirmationCancelled(pending.toolName, "all requests cancelled")
-      );
-    }
-    this.pendingConfirmations.clear();
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  EventBasedConfirmationProvider
-});

package/dist/tools/confirmation/event-based-confirmation-provider.d.cts

@@ -1,41 +0,0 @@
-import { ToolConfirmationProvider, ToolExecutionDetails, ToolConfirmationResponse } from './types.cjs';
-import { IAllowedToolsProvider } from './allowed-tools-provider/types.cjs';
-import { AgentEventBus } from '../../events/index.cjs';
-import 'events';
-import '../../llm/types.cjs';
-import '../../agent/schemas.cjs';
-import 'zod';
-
-/**
- * Event-based tool confirmation provider that uses the official AgentEventBus
- * to emit events for confirmation requests and wait for responses.
- * This decouples the core logic from UI-specific implementations.
- */
-declare class EventBasedConfirmationProvider implements ToolConfirmationProvider {
-    allowedToolsProvider: IAllowedToolsProvider;
-    private pendingConfirmations;
-    private confirmationTimeout;
-    private agentEventBus;
-    constructor(allowedToolsProvider: IAllowedToolsProvider, agentEventBus: AgentEventBus, options: {
-        confirmationTimeout: number;
-    });
-    requestConfirmation(details: ToolExecutionDetails): Promise<boolean>;
-    /**
-     * Handle confirmation response from external handlers
-     */
-    handleConfirmationResponse(response: ToolConfirmationResponse): Promise<void>;
-    /**
-     * Get list of pending confirmation requests
-     */
-    getPendingConfirmations(): string[];
-    /**
-     * Cancel a pending confirmation request
-     */
-    cancelConfirmation(executionId: string): void;
-    /**
-     * Cancel all pending confirmation requests
-     */
-    cancelAllConfirmations(): void;
-}
-
-export { EventBasedConfirmationProvider };

package/dist/tools/confirmation/event-based-confirmation-provider.d.ts

@@ -1,41 +0,0 @@
-import { ToolConfirmationProvider, ToolExecutionDetails, ToolConfirmationResponse } from './types.js';
-import { IAllowedToolsProvider } from './allowed-tools-provider/types.js';
-import { AgentEventBus } from '../../events/index.js';
-import 'events';
-import '../../llm/types.js';
-import '../../agent/schemas.js';
-import 'zod';
-
-/**
- * Event-based tool confirmation provider that uses the official AgentEventBus
- * to emit events for confirmation requests and wait for responses.
- * This decouples the core logic from UI-specific implementations.
- */
-declare class EventBasedConfirmationProvider implements ToolConfirmationProvider {
-    allowedToolsProvider: IAllowedToolsProvider;
-    private pendingConfirmations;
-    private confirmationTimeout;
-    private agentEventBus;
-    constructor(allowedToolsProvider: IAllowedToolsProvider, agentEventBus: AgentEventBus, options: {
-        confirmationTimeout: number;
-    });
-    requestConfirmation(details: ToolExecutionDetails): Promise<boolean>;
-    /**
-     * Handle confirmation response from external handlers
-     */
-    handleConfirmationResponse(response: ToolConfirmationResponse): Promise<void>;
-    /**
-     * Get list of pending confirmation requests
-     */
-    getPendingConfirmations(): string[];
-    /**
-     * Cancel a pending confirmation request
-     */
-    cancelConfirmation(executionId: string): void;
-    /**
-     * Cancel all pending confirmation requests
-     */
-    cancelAllConfirmations(): void;
-}
-
-export { EventBasedConfirmationProvider };

package/dist/tools/confirmation/event-based-confirmation-provider.js

@@ -1,134 +0,0 @@
-import { randomUUID } from "crypto";
-import { logger } from "../../logger/index.js";
-import { ToolError } from "../errors.js";
-class EventBasedConfirmationProvider {
-  constructor(allowedToolsProvider, agentEventBus, options) {
-    this.allowedToolsProvider = allowedToolsProvider;
-    this.agentEventBus = agentEventBus;
-    this.confirmationTimeout = options.confirmationTimeout;
-    this.agentEventBus.on(
-      "dexto:toolConfirmationResponse",
-      this.handleConfirmationResponse.bind(this)
-    );
-  }
-  pendingConfirmations = /* @__PURE__ */ new Map();
-  confirmationTimeout;
-  agentEventBus;
-  async requestConfirmation(details) {
-    const isAllowed = await this.allowedToolsProvider.isToolAllowed(
-      details.toolName,
-      details.sessionId
-    );
-    if (isAllowed) {
-      logger.info(
-        `Tool '${details.toolName}' already allowed for session '${details.sessionId ?? "global"}' \u2013 skipping confirmation.`
-      );
-      return true;
-    }
-    const executionId = randomUUID();
-    const event = {
-      toolName: details.toolName,
-      args: details.args,
-      ...details.description && { description: details.description },
-      executionId,
-      timestamp: /* @__PURE__ */ new Date(),
-      ...details.sessionId && { sessionId: details.sessionId }
-      // session context
-    };
-    logger.info(
-      `Tool confirmation requested for ${details.toolName}, executionId: ${executionId}, sessionId: ${details.sessionId}`
-    );
-    return new Promise((resolve, reject) => {
-      const timeout = setTimeout(() => {
-        const timeoutResponse = {
-          executionId,
-          approved: false,
-          rememberChoice: false,
-          ...details.sessionId && { sessionId: details.sessionId }
-        };
-        logger.warn(
-          `Tool confirmation timeout for ${details.toolName}, executionId: ${executionId}`
-        );
-        this.pendingConfirmations.delete(executionId);
-        this.agentEventBus.emit("dexto:toolConfirmationResponse", timeoutResponse);
-        reject(
-          ToolError.confirmationTimeout(
-            details.toolName,
-            this.confirmationTimeout,
-            details.sessionId
-          )
-        );
-      }, this.confirmationTimeout);
-      this.pendingConfirmations.set(executionId, {
-        resolve: (approved) => {
-          clearTimeout(timeout);
-          this.pendingConfirmations.delete(executionId);
-          resolve(approved);
-        },
-        reject: (error) => {
-          clearTimeout(timeout);
-          this.pendingConfirmations.delete(executionId);
-          reject(error);
-        },
-        toolName: details.toolName,
-        ...details.sessionId && { sessionId: details.sessionId }
-      });
-      this.agentEventBus.emit("dexto:toolConfirmationRequest", event);
-    });
-  }
-  /**
-   * Handle confirmation response from external handlers
-   */
-  async handleConfirmationResponse(response) {
-    const pending = this.pendingConfirmations.get(response.executionId);
-    if (!pending) {
-      logger.warn(
-        `Received toolConfirmationResponse for unknown executionId ${response.executionId}`
-      );
-      return;
-    }
-    this.pendingConfirmations.delete(response.executionId);
-    if (response.approved && response.rememberChoice) {
-      await this.allowedToolsProvider.allowTool(pending.toolName, response.sessionId);
-      logger.info(
-        `Tool '${pending.toolName}' added to allowed tools for session '${response.sessionId ?? "global"}' (remember choice selected)`
-      );
-    }
-    logger.info(
-      `Tool confirmation ${response.approved ? "approved" : "denied"} for ${pending.toolName}, executionId: ${response.executionId}, sessionId: ${response.sessionId ?? "global"}`
-    );
-    pending.resolve(response.approved);
-  }
-  /**
-   * Get list of pending confirmation requests
-   */
-  getPendingConfirmations() {
-    return Array.from(this.pendingConfirmations.keys());
-  }
-  /**
-   * Cancel a pending confirmation request
-   */
-  cancelConfirmation(executionId) {
-    const pending = this.pendingConfirmations.get(executionId);
-    if (pending) {
-      pending.reject(
-        ToolError.confirmationCancelled(pending.toolName, "individual request cancelled")
-      );
-      this.pendingConfirmations.delete(executionId);
-    }
-  }
-  /**
-   * Cancel all pending confirmation requests
-   */
-  cancelAllConfirmations() {
-    for (const [_executionId, pending] of this.pendingConfirmations) {
-      pending.reject(
-        ToolError.confirmationCancelled(pending.toolName, "all requests cancelled")
-      );
-    }
-    this.pendingConfirmations.clear();
-  }
-}
-export {
-  EventBasedConfirmationProvider
-};

package/dist/tools/confirmation/factory.cjs

@@ -1,52 +0,0 @@
-"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, {
-  createToolConfirmationProvider: () => createToolConfirmationProvider
-});
-module.exports = __toCommonJS(factory_exports);
-var import_event_based_confirmation_provider = require("./event-based-confirmation-provider.js");
-var import_noop_confirmation_provider = require("./noop-confirmation-provider.js");
-var import_errors = require("../errors.js");
-function createToolConfirmationProvider(options) {
-  switch (options.mode) {
-    case "event-based":
-      return new import_event_based_confirmation_provider.EventBasedConfirmationProvider(
-        options.allowedToolsProvider,
-        options.agentEventBus,
-        {
-          confirmationTimeout: options.confirmationTimeout
-        }
-      );
-    case "auto-approve":
-      return new import_noop_confirmation_provider.NoOpConfirmationProvider(options.allowedToolsProvider);
-    case "auto-deny":
-      return new import_noop_confirmation_provider.NoOpConfirmationProvider(options.allowedToolsProvider, false);
-    default: {
-      const _exhaustive = options;
-      throw import_errors.ToolError.configInvalid(
-        `Unsupported ToolConfirmationMode: ${options?.mode}`
-      );
-    }
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  createToolConfirmationProvider
-});

package/dist/tools/confirmation/factory.d.cts

@@ -1,37 +0,0 @@
-import { ToolConfirmationProvider } from './types.cjs';
-import { IAllowedToolsProvider } from './allowed-tools-provider/types.cjs';
-import { AgentEventBus } from '../../events/index.cjs';
-import 'events';
-import '../../llm/types.cjs';
-import '../../agent/schemas.cjs';
-import 'zod';
-
-/**
- * ToolConfirmationProvider Factory
- *
- * Creates ToolConfirmationProvider instances with all required configuration.
- * All fields are mandatory - no defaults or fallbacks.
- *
- * Usage:
- *   import { createToolConfirmationProvider } from './factory.js';
- *   const provider = createToolConfirmationProvider({
- *     mode: 'event-based',
- *     allowedToolsProvider,
- *     confirmationTimeout: 120000,
- *     agentEventBus
- *   });
- */
-
-type ToolConfirmationMode = 'event-based' | 'auto-approve' | 'auto-deny';
-type ToolConfirmationOptions = {
-    mode: 'event-based';
-    allowedToolsProvider: IAllowedToolsProvider;
-    confirmationTimeout: number;
-    agentEventBus: AgentEventBus;
-} | {
-    mode: 'auto-approve' | 'auto-deny';
-    allowedToolsProvider: IAllowedToolsProvider;
-};
-declare function createToolConfirmationProvider(options: ToolConfirmationOptions): ToolConfirmationProvider;
-
-export { type ToolConfirmationMode, type ToolConfirmationOptions, createToolConfirmationProvider };

package/dist/tools/confirmation/factory.d.ts

@@ -1,37 +0,0 @@
-import { ToolConfirmationProvider } from './types.js';
-import { IAllowedToolsProvider } from './allowed-tools-provider/types.js';
-import { AgentEventBus } from '../../events/index.js';
-import 'events';
-import '../../llm/types.js';
-import '../../agent/schemas.js';
-import 'zod';
-
-/**
- * ToolConfirmationProvider Factory
- *
- * Creates ToolConfirmationProvider instances with all required configuration.
- * All fields are mandatory - no defaults or fallbacks.
- *
- * Usage:
- *   import { createToolConfirmationProvider } from './factory.js';
- *   const provider = createToolConfirmationProvider({
- *     mode: 'event-based',
- *     allowedToolsProvider,
- *     confirmationTimeout: 120000,
- *     agentEventBus
- *   });
- */
-
-type ToolConfirmationMode = 'event-based' | 'auto-approve' | 'auto-deny';
-type ToolConfirmationOptions = {
-    mode: 'event-based';
-    allowedToolsProvider: IAllowedToolsProvider;
-    confirmationTimeout: number;
-    agentEventBus: AgentEventBus;
-} | {
-    mode: 'auto-approve' | 'auto-deny';
-    allowedToolsProvider: IAllowedToolsProvider;
-};
-declare function createToolConfirmationProvider(options: ToolConfirmationOptions): ToolConfirmationProvider;
-
-export { type ToolConfirmationMode, type ToolConfirmationOptions, createToolConfirmationProvider };

package/dist/tools/confirmation/factory.js

@@ -1,28 +0,0 @@
-import { EventBasedConfirmationProvider } from "./event-based-confirmation-provider.js";
-import { NoOpConfirmationProvider } from "./noop-confirmation-provider.js";
-import { ToolError } from "../errors.js";
-function createToolConfirmationProvider(options) {
-  switch (options.mode) {
-    case "event-based":
-      return new EventBasedConfirmationProvider(
-        options.allowedToolsProvider,
-        options.agentEventBus,
-        {
-          confirmationTimeout: options.confirmationTimeout
-        }
-      );
-    case "auto-approve":
-      return new NoOpConfirmationProvider(options.allowedToolsProvider);
-    case "auto-deny":
-      return new NoOpConfirmationProvider(options.allowedToolsProvider, false);
-    default: {
-      const _exhaustive = options;
-      throw ToolError.configInvalid(
-        `Unsupported ToolConfirmationMode: ${options?.mode}`
-      );
-    }
-  }
-}
-export {
-  createToolConfirmationProvider
-};