@dexto/core 1.1.4 → 1.1.6

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

@@ -0,0 +1,134 @@
+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

@@ -0,0 +1,52 @@
+"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

@@ -0,0 +1,37 @@
+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

@@ -0,0 +1,37 @@
+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

@@ -0,0 +1,28 @@
+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
+};

package/dist/tools/confirmation/noop-confirmation-provider.cjs

@@ -0,0 +1,49 @@
+"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_confirmation_provider_exports = {};
+__export(noop_confirmation_provider_exports, {
+  NoOpConfirmationProvider: () => NoOpConfirmationProvider
+});
+module.exports = __toCommonJS(noop_confirmation_provider_exports);
+var import_in_memory = require("./allowed-tools-provider/in-memory.js");
+var import_logger = require("../../logger/index.cjs");
+class NoOpConfirmationProvider {
+  allowedToolsProvider;
+  autoApprove;
+  constructor(allowedToolsProvider, autoApprove = true) {
+    this.allowedToolsProvider = allowedToolsProvider ?? new import_in_memory.InMemoryAllowedToolsProvider();
+    this.autoApprove = autoApprove;
+  }
+  async requestConfirmation(details) {
+    if (this.autoApprove) {
+      import_logger.logger.info(
+        `Tool confirmation auto-approved for ${details.toolName}, sessionId: ${details.sessionId ?? "global"} (auto-approve mode)`
+      );
+    } else {
+      import_logger.logger.info(
+        `Tool confirmation auto-denied for ${details.toolName}, sessionId: ${details.sessionId ?? "global"} (auto-deny mode)`
+      );
+    }
+    return this.autoApprove;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NoOpConfirmationProvider
+});

package/dist/tools/confirmation/noop-confirmation-provider.d.cts

@@ -0,0 +1,22 @@
+import { ToolConfirmationProvider, ToolExecutionDetails } from './types.cjs';
+import { IAllowedToolsProvider } from './allowed-tools-provider/types.cjs';
+
+/**
+ * NoOpConfirmationProvider
+ *
+ * A ToolConfirmationProvider implementation that always approves or denies tool execution.
+ * Used as a fallback for environments where confirmation is not implemented or for
+ * security scenarios where tools should be automatically denied.
+ *
+ * Uses InMemoryAllowedToolsProvider to satisfy the interface, but does not enforce any restrictions
+ * when in auto-approve mode.
+ */
+
+declare class NoOpConfirmationProvider implements ToolConfirmationProvider {
+    allowedToolsProvider: IAllowedToolsProvider;
+    private autoApprove;
+    constructor(allowedToolsProvider?: IAllowedToolsProvider, autoApprove?: boolean);
+    requestConfirmation(details: ToolExecutionDetails): Promise<boolean>;
+}
+
+export { NoOpConfirmationProvider };

package/dist/tools/confirmation/noop-confirmation-provider.d.ts

@@ -0,0 +1,22 @@
+import { ToolConfirmationProvider, ToolExecutionDetails } from './types.js';
+import { IAllowedToolsProvider } from './allowed-tools-provider/types.js';
+
+/**
+ * NoOpConfirmationProvider
+ *
+ * A ToolConfirmationProvider implementation that always approves or denies tool execution.
+ * Used as a fallback for environments where confirmation is not implemented or for
+ * security scenarios where tools should be automatically denied.
+ *
+ * Uses InMemoryAllowedToolsProvider to satisfy the interface, but does not enforce any restrictions
+ * when in auto-approve mode.
+ */
+
+declare class NoOpConfirmationProvider implements ToolConfirmationProvider {
+    allowedToolsProvider: IAllowedToolsProvider;
+    private autoApprove;
+    constructor(allowedToolsProvider?: IAllowedToolsProvider, autoApprove?: boolean);
+    requestConfirmation(details: ToolExecutionDetails): Promise<boolean>;
+}
+
+export { NoOpConfirmationProvider };

package/dist/tools/confirmation/noop-confirmation-provider.js

@@ -0,0 +1,25 @@
+import { InMemoryAllowedToolsProvider } from "./allowed-tools-provider/in-memory.js";
+import { logger } from "../../logger/index.js";
+class NoOpConfirmationProvider {
+  allowedToolsProvider;
+  autoApprove;
+  constructor(allowedToolsProvider, autoApprove = true) {
+    this.allowedToolsProvider = allowedToolsProvider ?? new InMemoryAllowedToolsProvider();
+    this.autoApprove = autoApprove;
+  }
+  async requestConfirmation(details) {
+    if (this.autoApprove) {
+      logger.info(
+        `Tool confirmation auto-approved for ${details.toolName}, sessionId: ${details.sessionId ?? "global"} (auto-approve mode)`
+      );
+    } else {
+      logger.info(
+        `Tool confirmation auto-denied for ${details.toolName}, sessionId: ${details.sessionId ?? "global"} (auto-deny mode)`
+      );
+    }
+    return this.autoApprove;
+  }
+}
+export {
+  NoOpConfirmationProvider
+};

package/dist/tools/confirmation/types.cjs

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 types_exports = {};
+module.exports = __toCommonJS(types_exports);

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

@@ -0,0 +1,46 @@
+import { IAllowedToolsProvider } from './allowed-tools-provider/types.cjs';
+
+/**
+ * Event emitted when tool confirmation is requested
+ */
+interface ToolConfirmationEvent {
+    toolName: string;
+    args: Record<string, unknown>;
+    description?: string | undefined;
+    executionId: string;
+    timestamp: Date;
+    sessionId?: string;
+}
+/**
+ * Response to tool confirmation request
+ */
+interface ToolConfirmationResponse {
+    executionId: string;
+    approved: boolean;
+    rememberChoice?: boolean;
+    /**
+     * Optional session identifier to scope the approval. When provided, a
+     * "remembered" approval is stored only for this session by the
+     * AllowedToolsProvider implementation.
+     */
+    sessionId?: string;
+}
+/**
+ * Interface for current tool being executed
+ */
+interface ToolExecutionDetails {
+    toolName: string;
+    args: Record<string, unknown>;
+    description?: string;
+    sessionId?: string;
+}
+/**
+ * Interface to get tool confirmation and manage allowed tools
+ */
+interface ToolConfirmationProvider {
+    allowedToolsProvider: IAllowedToolsProvider;
+    requestConfirmation(details: ToolExecutionDetails): Promise<boolean>;
+    handleConfirmationResponse?(response: ToolConfirmationResponse): Promise<void>;
+}
+
+export type { ToolConfirmationEvent, ToolConfirmationProvider, ToolConfirmationResponse, ToolExecutionDetails };

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

@@ -0,0 +1,46 @@
+import { IAllowedToolsProvider } from './allowed-tools-provider/types.js';
+
+/**
+ * Event emitted when tool confirmation is requested
+ */
+interface ToolConfirmationEvent {
+    toolName: string;
+    args: Record<string, unknown>;
+    description?: string | undefined;
+    executionId: string;
+    timestamp: Date;
+    sessionId?: string;
+}
+/**
+ * Response to tool confirmation request
+ */
+interface ToolConfirmationResponse {
+    executionId: string;
+    approved: boolean;
+    rememberChoice?: boolean;
+    /**
+     * Optional session identifier to scope the approval. When provided, a
+     * "remembered" approval is stored only for this session by the
+     * AllowedToolsProvider implementation.
+     */
+    sessionId?: string;
+}
+/**
+ * Interface for current tool being executed
+ */
+interface ToolExecutionDetails {
+    toolName: string;
+    args: Record<string, unknown>;
+    description?: string;
+    sessionId?: string;
+}
+/**
+ * Interface to get tool confirmation and manage allowed tools
+ */
+interface ToolConfirmationProvider {
+    allowedToolsProvider: IAllowedToolsProvider;
+    requestConfirmation(details: ToolExecutionDetails): Promise<boolean>;
+    handleConfirmationResponse?(response: ToolConfirmationResponse): Promise<void>;
+}
+
+export type { ToolConfirmationEvent, ToolConfirmationProvider, ToolConfirmationResponse, ToolExecutionDetails };

package/dist/tools/error-codes.cjs

@@ -0,0 +1,40 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var error_codes_exports = {};
+__export(error_codes_exports, {
+  ToolErrorCode: () => ToolErrorCode
+});
+module.exports = __toCommonJS(error_codes_exports);
+var ToolErrorCode = /* @__PURE__ */ ((ToolErrorCode2) => {
+  ToolErrorCode2["EXECUTION_DENIED"] = "tools_execution_denied";
+  ToolErrorCode2["EXECUTION_TIMEOUT"] = "tools_execution_timeout";
+  ToolErrorCode2["EXECUTION_FAILED"] = "tools_execution_failed";
+  ToolErrorCode2["CONFIRMATION_HANDLER_MISSING"] = "tools_confirmation_handler_missing";
+  ToolErrorCode2["CONFIRMATION_TIMEOUT"] = "tools_confirmation_timeout";
+  ToolErrorCode2["CONFIRMATION_CANCELLED"] = "tools_confirmation_cancelled";
+  ToolErrorCode2["TOOL_NOT_FOUND"] = "tools_tool_not_found";
+  ToolErrorCode2["TOOL_INVALID_ARGS"] = "tools_invalid_args";
+  ToolErrorCode2["TOOL_UNAUTHORIZED"] = "tools_unauthorized";
+  ToolErrorCode2["CONFIG_INVALID"] = "tools_config_invalid";
+  return ToolErrorCode2;
+})(ToolErrorCode || {});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ToolErrorCode
+});

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

@@ -0,0 +1,18 @@
+/**
+ * Tools-specific error codes
+ * Includes tool execution, confirmation, and authorization errors
+ */
+declare enum ToolErrorCode {
+    EXECUTION_DENIED = "tools_execution_denied",
+    EXECUTION_TIMEOUT = "tools_execution_timeout",
+    EXECUTION_FAILED = "tools_execution_failed",
+    CONFIRMATION_HANDLER_MISSING = "tools_confirmation_handler_missing",
+    CONFIRMATION_TIMEOUT = "tools_confirmation_timeout",
+    CONFIRMATION_CANCELLED = "tools_confirmation_cancelled",
+    TOOL_NOT_FOUND = "tools_tool_not_found",
+    TOOL_INVALID_ARGS = "tools_invalid_args",
+    TOOL_UNAUTHORIZED = "tools_unauthorized",
+    CONFIG_INVALID = "tools_config_invalid"
+}
+
+export { ToolErrorCode };

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

@@ -0,0 +1,18 @@
+/**
+ * Tools-specific error codes
+ * Includes tool execution, confirmation, and authorization errors
+ */
+declare enum ToolErrorCode {
+    EXECUTION_DENIED = "tools_execution_denied",
+    EXECUTION_TIMEOUT = "tools_execution_timeout",
+    EXECUTION_FAILED = "tools_execution_failed",
+    CONFIRMATION_HANDLER_MISSING = "tools_confirmation_handler_missing",
+    CONFIRMATION_TIMEOUT = "tools_confirmation_timeout",
+    CONFIRMATION_CANCELLED = "tools_confirmation_cancelled",
+    TOOL_NOT_FOUND = "tools_tool_not_found",
+    TOOL_INVALID_ARGS = "tools_invalid_args",
+    TOOL_UNAUTHORIZED = "tools_unauthorized",
+    CONFIG_INVALID = "tools_config_invalid"
+}
+
+export { ToolErrorCode };

package/dist/tools/error-codes.js

@@ -0,0 +1,16 @@
+var ToolErrorCode = /* @__PURE__ */ ((ToolErrorCode2) => {
+  ToolErrorCode2["EXECUTION_DENIED"] = "tools_execution_denied";
+  ToolErrorCode2["EXECUTION_TIMEOUT"] = "tools_execution_timeout";
+  ToolErrorCode2["EXECUTION_FAILED"] = "tools_execution_failed";
+  ToolErrorCode2["CONFIRMATION_HANDLER_MISSING"] = "tools_confirmation_handler_missing";
+  ToolErrorCode2["CONFIRMATION_TIMEOUT"] = "tools_confirmation_timeout";
+  ToolErrorCode2["CONFIRMATION_CANCELLED"] = "tools_confirmation_cancelled";
+  ToolErrorCode2["TOOL_NOT_FOUND"] = "tools_tool_not_found";
+  ToolErrorCode2["TOOL_INVALID_ARGS"] = "tools_invalid_args";
+  ToolErrorCode2["TOOL_UNAUTHORIZED"] = "tools_unauthorized";
+  ToolErrorCode2["CONFIG_INVALID"] = "tools_config_invalid";
+  return ToolErrorCode2;
+})(ToolErrorCode || {});
+export {
+  ToolErrorCode
+};