@dexto/core 1.2.6 → 1.4.0

package/dist/telemetry/telemetry.js

@@ -1,14 +1,8 @@
-import "../chunk-C6A6W6XS.js";
+import "../chunk-PTJYTZNU.js";
 import { context as otlpContext, trace, propagation } from "@opentelemetry/api";
-import { NodeSDK } from "@opentelemetry/sdk-node";
-import { ConsoleSpanExporter } from "@opentelemetry/sdk-trace-base";
-import { OTLPTraceExporter as OTLPHttpExporter } from "@opentelemetry/exporter-trace-otlp-http";
-import { OTLPTraceExporter as OTLPGrpcExporter } from "@opentelemetry/exporter-trace-otlp-grpc";
-import { getNodeAutoInstrumentations } from "@opentelemetry/auto-instrumentations-node";
-import { Resource } from "@opentelemetry/resources";
-import { ATTR_SERVICE_NAME } from "@opentelemetry/semantic-conventions";
-import { CompositeExporter } from "./exporters.js";
 import { logger } from "../logger/logger.js";
+import { TelemetryError } from "./errors.js";
+import { DextoRuntimeError } from "../errors/DextoRuntimeError.js";
 class Telemetry {
   tracer = trace.getTracer("dexto");
   name = "dexto-service";
@@ -26,19 +20,48 @@ class Telemetry {
     }
     this._isInitialized = enabled && !!sdk;
   }
-  static buildTraceExporter(config) {
+  static async buildTraceExporter(config) {
     const e = config?.export;
     if (!e || e.type === "console") {
-      return new ConsoleSpanExporter();
+      const { ConsoleSpanExporter: ConsoleSpanExporter2 } = await import("@opentelemetry/sdk-trace-base");
+      return new ConsoleSpanExporter2();
     }
     if (e.type === "otlp") {
       if (e.protocol === "grpc") {
+        let OTLPGrpcExporter;
+        try {
+          const mod = await import("@opentelemetry/exporter-trace-otlp-grpc");
+          OTLPGrpcExporter = mod.OTLPTraceExporter;
+        } catch (err) {
+          const error = err;
+          if (error.code === "ERR_MODULE_NOT_FOUND") {
+            throw TelemetryError.exporterDependencyNotInstalled(
+              "grpc",
+              "@opentelemetry/exporter-trace-otlp-grpc"
+            );
+          }
+          throw err;
+        }
         const options2 = {};
         if (e.endpoint) {
           options2.url = e.endpoint;
         }
         return new OTLPGrpcExporter(options2);
       }
+      let OTLPHttpExporter;
+      try {
+        const mod = await import("@opentelemetry/exporter-trace-otlp-http");
+        OTLPHttpExporter = mod.OTLPTraceExporter;
+      } catch (err) {
+        const error = err;
+        if (error.code === "ERR_MODULE_NOT_FOUND") {
+          throw TelemetryError.exporterDependencyNotInstalled(
+            "http",
+            "@opentelemetry/exporter-trace-otlp-http"
+          );
+        }
+        throw err;
+      }
       const options = {};
       if (e.endpoint) {
         options.url = e.endpoint;
@@ -48,6 +71,7 @@ class Telemetry {
       }
       return new OTLPHttpExporter(options);
     }
+    const { ConsoleSpanExporter } = await import("@opentelemetry/sdk-trace-base");
     return new ConsoleSpanExporter();
   }
   /**
@@ -65,10 +89,39 @@ class Telemetry {
           const enabled = config.enabled !== false;
           let sdk;
           if (enabled) {
+            let NodeSDK;
+            let Resource;
+            let getNodeAutoInstrumentations;
+            let ATTR_SERVICE_NAME;
+            try {
+              const sdkModule = await import("@opentelemetry/sdk-node");
+              NodeSDK = sdkModule.NodeSDK;
+              const resourcesModule = await import("@opentelemetry/resources");
+              Resource = resourcesModule.Resource;
+              const autoInstModule = await import("@opentelemetry/auto-instrumentations-node");
+              getNodeAutoInstrumentations = autoInstModule.getNodeAutoInstrumentations;
+              const semanticModule = await import("@opentelemetry/semantic-conventions");
+              ATTR_SERVICE_NAME = semanticModule.ATTR_SERVICE_NAME;
+            } catch (importError) {
+              const err = importError;
+              if (err.code === "ERR_MODULE_NOT_FOUND") {
+                throw TelemetryError.dependencyNotInstalled([
+                  "@opentelemetry/sdk-node",
+                  "@opentelemetry/auto-instrumentations-node",
+                  "@opentelemetry/resources",
+                  "@opentelemetry/semantic-conventions",
+                  "@opentelemetry/sdk-trace-base",
+                  "@opentelemetry/exporter-trace-otlp-http",
+                  "@opentelemetry/exporter-trace-otlp-grpc"
+                ]);
+              }
+              throw importError;
+            }
             const resource = new Resource({
               [ATTR_SERVICE_NAME]: config.serviceName ?? "dexto-service"
             });
-            const spanExporter = exporter || Telemetry.buildTraceExporter(config);
+            const spanExporter = exporter || await Telemetry.buildTraceExporter(config);
+            const { CompositeExporter } = await import("./exporters.js");
             const traceExporter = spanExporter instanceof CompositeExporter ? spanExporter : new CompositeExporter([spanExporter]);
             sdk = new NodeSDK({
               resource,
@@ -90,13 +143,16 @@ class Telemetry {
         }
         return globalThis.__TELEMETRY__;
       })();
-      return Telemetry._initPromise;
+      return await Telemetry._initPromise;
     } catch (error) {
-      const wrappedError = new Error(
-        `Failed to initialize telemetry: ${error instanceof Error ? error.message : String(error)}`
-      );
       Telemetry._initPromise = void 0;
-      throw wrappedError;
+      if (error instanceof DextoRuntimeError) {
+        throw error;
+      }
+      throw TelemetryError.initializationFailed(
+        error instanceof Error ? error.message : String(error),
+        error
+      );
     }
   }
   static getActiveSpan() {
@@ -105,12 +161,12 @@ class Telemetry {
   }
   /**
    * Get the global telemetry instance
-   * @throws {Error} If telemetry has not been initialized
+   * @throws {DextoRuntimeError} If telemetry has not been initialized
    * @returns {Telemetry} The global telemetry instance
    */
   static get() {
     if (!globalThis.__TELEMETRY__) {
-      throw new Error("Telemetry not initialized");
+      throw TelemetryError.notInitialized();
     }
     return globalThis.__TELEMETRY__;
   }

package/dist/telemetry/utils.js

@@ -1,4 +1,4 @@
-import "../chunk-C6A6W6XS.js";
+import "../chunk-PTJYTZNU.js";
 import { propagation } from "@opentelemetry/api";
 import { Telemetry } from "./telemetry.js";
 function hasActiveTelemetry(logger) {

package/dist/tools/bash-pattern-utils.cjs

@@ -0,0 +1,91 @@
+"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 bash_pattern_utils_exports = {};
+__export(bash_pattern_utils_exports, {
+  DANGEROUS_COMMAND_PREFIXES: () => DANGEROUS_COMMAND_PREFIXES,
+  generateBashPatternKey: () => generateBashPatternKey,
+  generateBashPatternSuggestions: () => generateBashPatternSuggestions,
+  isDangerousCommand: () => isDangerousCommand,
+  patternCovers: () => patternCovers
+});
+module.exports = __toCommonJS(bash_pattern_utils_exports);
+function patternCovers(storedPattern, targetPatternKey) {
+  if (storedPattern === targetPatternKey) return true;
+  const storedBase = storedPattern.endsWith(" *") ? storedPattern.slice(0, -2) : storedPattern;
+  const targetBase = targetPatternKey.endsWith(" *") ? targetPatternKey.slice(0, -2) : targetPatternKey;
+  return targetBase.startsWith(storedBase + " ");
+}
+const DANGEROUS_COMMAND_PREFIXES = [
+  "rm",
+  "chmod",
+  "chown",
+  "chgrp",
+  "sudo",
+  "su",
+  "dd",
+  "mkfs",
+  "fdisk",
+  "parted",
+  "kill",
+  "killall",
+  "pkill",
+  "shutdown",
+  "reboot",
+  "halt",
+  "poweroff"
+];
+function isDangerousCommand(command) {
+  const tokens = command.trim().split(/\s+/);
+  if (tokens.length === 0 || !tokens[0]) return false;
+  const head = tokens[0].toLowerCase();
+  return DANGEROUS_COMMAND_PREFIXES.includes(head);
+}
+function generateBashPatternKey(command) {
+  const tokens = command.trim().split(/\s+/);
+  if (tokens.length === 0 || !tokens[0]) return null;
+  const head = tokens[0];
+  if (isDangerousCommand(command)) {
+    return null;
+  }
+  const subcommand = tokens.slice(1).find((arg) => !arg.startsWith("-"));
+  return subcommand ? `${head} ${subcommand} *` : `${head} *`;
+}
+function generateBashPatternSuggestions(command) {
+  const tokens = command.trim().split(/\s+/);
+  if (tokens.length === 0 || !tokens[0]) return [];
+  const head = tokens[0];
+  if (isDangerousCommand(command)) {
+    return [];
+  }
+  const patterns = [];
+  const nonFlagArgs = tokens.slice(1).filter((arg) => !arg.startsWith("-"));
+  if (nonFlagArgs.length > 0) {
+    patterns.push(`${head} ${nonFlagArgs[0]} *`);
+  }
+  patterns.push(`${head} *`);
+  return patterns;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DANGEROUS_COMMAND_PREFIXES,
+  generateBashPatternKey,
+  generateBashPatternSuggestions,
+  isDangerousCommand,
+  patternCovers
+});

package/dist/tools/bash-pattern-utils.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Utility functions for bash command pattern generation and matching.
+ *
+ * Pattern-based approval allows users to approve command patterns like "git *"
+ * that automatically cover future matching commands (e.g., "git status", "git push").
+ */
+/**
+ * Check if a stored pattern covers a target pattern key.
+ * Pattern A covers pattern B if:
+ * 1. A == B (exact match), OR
+ * 2. B's base starts with A's base + " " (broader pattern covers narrower)
+ *
+ * Examples:
+ * - `git *` covers `git push *`: base `git` is prefix of base `git push`
+ * - `ls *` covers `ls *`: exact match
+ * - `npm *` does NOT cover `npx *`: `npx` doesn't start with `npm `
+ *
+ * @param storedPattern The approved pattern (e.g., "git *")
+ * @param targetPatternKey The pattern key to check (e.g., "git push *")
+ * @returns true if storedPattern covers targetPatternKey
+ */
+export declare function patternCovers(storedPattern: string, targetPatternKey: string): boolean;
+/**
+ * Commands that should never get auto-approve pattern suggestions.
+ * These require explicit approval each time for safety.
+ */
+export declare const DANGEROUS_COMMAND_PREFIXES: readonly ["rm", "chmod", "chown", "chgrp", "sudo", "su", "dd", "mkfs", "fdisk", "parted", "kill", "killall", "pkill", "shutdown", "reboot", "halt", "poweroff"];
+/**
+ * Check if a command prefix is dangerous (should not get pattern suggestions).
+ */
+export declare function isDangerousCommand(command: string): boolean;
+/**
+ * Generate the pattern key for a bash command.
+ * This is what gets stored when user approves, and what gets checked against approved patterns.
+ *
+ * Examples:
+ * - "ls -la" → "ls *" (flags don't count as subcommand)
+ * - "git push origin" → "git push *" (first non-flag arg is subcommand)
+ * - "git status" → "git status *"
+ * - "rm -rf /" → null (dangerous command)
+ *
+ * @param command The bash command to generate a pattern key for
+ * @returns The pattern key, or null if the command is dangerous
+ */
+export declare function generateBashPatternKey(command: string): string | null;
+/**
+ * Generate suggested patterns for UI selection.
+ * Returns progressively broader patterns from specific to general.
+ *
+ * Example: "git push origin main" generates:
+ *   - "git push *" (the pattern key)
+ *   - "git *" (broader)
+ *
+ * @param command The bash command to generate suggestions for
+ * @returns Array of pattern suggestions (empty for dangerous commands)
+ */
+export declare function generateBashPatternSuggestions(command: string): string[];
+//# sourceMappingURL=bash-pattern-utils.d.ts.map

package/dist/tools/bash-pattern-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bash-pattern-utils.d.ts","sourceRoot":"","sources":["../../src/tools/bash-pattern-utils.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,aAAa,CAAC,aAAa,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,GAAG,OAAO,CAatF;AAED;;;GAGG;AACH,eAAO,MAAM,0BAA0B,iKAkB7B,CAAC;AAEX;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAK3D;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAerE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,8BAA8B,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAuBxE"}

package/dist/tools/bash-pattern-utils.js

@@ -0,0 +1,64 @@
+import "../chunk-PTJYTZNU.js";
+function patternCovers(storedPattern, targetPatternKey) {
+  if (storedPattern === targetPatternKey) return true;
+  const storedBase = storedPattern.endsWith(" *") ? storedPattern.slice(0, -2) : storedPattern;
+  const targetBase = targetPatternKey.endsWith(" *") ? targetPatternKey.slice(0, -2) : targetPatternKey;
+  return targetBase.startsWith(storedBase + " ");
+}
+const DANGEROUS_COMMAND_PREFIXES = [
+  "rm",
+  "chmod",
+  "chown",
+  "chgrp",
+  "sudo",
+  "su",
+  "dd",
+  "mkfs",
+  "fdisk",
+  "parted",
+  "kill",
+  "killall",
+  "pkill",
+  "shutdown",
+  "reboot",
+  "halt",
+  "poweroff"
+];
+function isDangerousCommand(command) {
+  const tokens = command.trim().split(/\s+/);
+  if (tokens.length === 0 || !tokens[0]) return false;
+  const head = tokens[0].toLowerCase();
+  return DANGEROUS_COMMAND_PREFIXES.includes(head);
+}
+function generateBashPatternKey(command) {
+  const tokens = command.trim().split(/\s+/);
+  if (tokens.length === 0 || !tokens[0]) return null;
+  const head = tokens[0];
+  if (isDangerousCommand(command)) {
+    return null;
+  }
+  const subcommand = tokens.slice(1).find((arg) => !arg.startsWith("-"));
+  return subcommand ? `${head} ${subcommand} *` : `${head} *`;
+}
+function generateBashPatternSuggestions(command) {
+  const tokens = command.trim().split(/\s+/);
+  if (tokens.length === 0 || !tokens[0]) return [];
+  const head = tokens[0];
+  if (isDangerousCommand(command)) {
+    return [];
+  }
+  const patterns = [];
+  const nonFlagArgs = tokens.slice(1).filter((arg) => !arg.startsWith("-"));
+  if (nonFlagArgs.length > 0) {
+    patterns.push(`${head} ${nonFlagArgs[0]} *`);
+  }
+  patterns.push(`${head} *`);
+  return patterns;
+}
+export {
+  DANGEROUS_COMMAND_PREFIXES,
+  generateBashPatternKey,
+  generateBashPatternSuggestions,
+  isDangerousCommand,
+  patternCovers
+};

package/dist/tools/confirmation/allowed-tools-provider/factory.js

@@ -1,4 +1,4 @@
-import "../../../chunk-C6A6W6XS.js";
+import "../../../chunk-PTJYTZNU.js";
 import { InMemoryAllowedToolsProvider } from "./in-memory.js";
 import { StorageAllowedToolsProvider } from "./storage.js";
 import { ToolError } from "../../errors.js";

package/dist/tools/confirmation/allowed-tools-provider/in-memory.js

@@ -1,4 +1,4 @@
-import "../../../chunk-C6A6W6XS.js";
+import "../../../chunk-PTJYTZNU.js";
 class InMemoryAllowedToolsProvider {
   /**
    * Map key is sessionId (undefined => global approvals). Value is a set of

package/dist/tools/confirmation/allowed-tools-provider/storage.js

@@ -1,4 +1,4 @@
-import "../../../chunk-C6A6W6XS.js";
+import "../../../chunk-PTJYTZNU.js";
 class StorageAllowedToolsProvider {
   constructor(storageManager, logger) {
     this.storageManager = storageManager;

package/dist/tools/display-types.cjs

@@ -0,0 +1,60 @@
+"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 display_types_exports = {};
+__export(display_types_exports, {
+  isDiffDisplay: () => isDiffDisplay,
+  isFileDisplay: () => isFileDisplay,
+  isGenericDisplay: () => isGenericDisplay,
+  isSearchDisplay: () => isSearchDisplay,
+  isShellDisplay: () => isShellDisplay,
+  isValidDisplayData: () => isValidDisplayData
+});
+module.exports = __toCommonJS(display_types_exports);
+function isDiffDisplay(d) {
+  return d.type === "diff";
+}
+function isShellDisplay(d) {
+  return d.type === "shell";
+}
+function isSearchDisplay(d) {
+  return d.type === "search";
+}
+function isFileDisplay(d) {
+  return d.type === "file";
+}
+function isGenericDisplay(d) {
+  return d.type === "generic";
+}
+const VALID_DISPLAY_TYPES = ["diff", "shell", "search", "file", "generic"];
+function isValidDisplayData(d) {
+  if (d === null || typeof d !== "object") {
+    return false;
+  }
+  const obj = d;
+  return typeof obj.type === "string" && VALID_DISPLAY_TYPES.includes(obj.type);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isDiffDisplay,
+  isFileDisplay,
+  isGenericDisplay,
+  isSearchDisplay,
+  isShellDisplay,
+  isValidDisplayData
+});

package/dist/tools/display-types.d.ts

@@ -0,0 +1,133 @@
+/**
+ * Tool Display Types
+ *
+ * Discriminated union types for structured tool result rendering.
+ * These types enable both CLI and WebUI to render tool results with
+ * appropriate formatting (diffs, shell output, search results, etc.)
+ *
+ * Tools return `_display` field in their result, which is preserved
+ * by the sanitizer in `SanitizedToolResult.meta.display`.
+ */
+/**
+ * Discriminated union of all tool display data types.
+ * Switch on `type` field for exhaustive handling.
+ */
+export type ToolDisplayData = DiffDisplayData | ShellDisplayData | SearchDisplayData | FileDisplayData | GenericDisplayData;
+/**
+ * Display data for file edit operations (edit_file, write_file overwrites).
+ * Contains unified diff format for rendering changes.
+ */
+export interface DiffDisplayData {
+    type: 'diff';
+    /** Unified diff string (output of `diff` package's createPatch) */
+    unified: string;
+    /** Path to the file that was modified */
+    filename: string;
+    /** Number of lines added */
+    additions: number;
+    /** Number of lines removed */
+    deletions: number;
+    /** Original file content (optional, for approval preview) */
+    beforeContent?: string;
+    /** New file content (optional, for approval preview) */
+    afterContent?: string;
+}
+/**
+ * Display data for shell command execution (bash_exec).
+ * Contains command metadata and output for structured rendering.
+ */
+export interface ShellDisplayData {
+    type: 'shell';
+    /** The command that was executed */
+    command: string;
+    /** Exit code from the command (0 = success) */
+    exitCode: number;
+    /** Execution duration in milliseconds */
+    duration: number;
+    /** Whether command is running in background */
+    isBackground?: boolean;
+    /** Standard output from the command */
+    stdout?: string;
+    /** Standard error from the command */
+    stderr?: string;
+}
+/**
+ * Display data for search operations (grep_content, glob_files).
+ * Contains structured match results for formatted rendering.
+ */
+export interface SearchDisplayData {
+    type: 'search';
+    /** The search pattern used */
+    pattern: string;
+    /** Array of match results */
+    matches: SearchMatch[];
+    /** Total number of matches found (may exceed displayed matches) */
+    totalMatches: number;
+    /** Whether results were truncated due to limits */
+    truncated: boolean;
+}
+/**
+ * Individual search match result.
+ */
+export interface SearchMatch {
+    /** File path where match was found */
+    file: string;
+    /** Line number of the match (0 for glob results) */
+    line: number;
+    /** Content of the matching line or filename */
+    content: string;
+    /** Optional surrounding context lines */
+    context?: string[];
+}
+/**
+ * Display data for file operations (read_file, write_file create).
+ * Contains file metadata for simple status rendering.
+ */
+export interface FileDisplayData {
+    type: 'file';
+    /** Path to the file */
+    path: string;
+    /** Type of operation performed */
+    operation: 'read' | 'write' | 'create' | 'delete';
+    /** File size in bytes (optional) */
+    size?: number;
+    /** Number of lines read/written (optional) */
+    lineCount?: number;
+    /** Path to backup file if created (optional) */
+    backupPath?: string;
+    /** File content for create operations (used in approval preview) */
+    content?: string;
+}
+/**
+ * Fallback display data for unknown tools or MCP tools.
+ * Renderers should fall back to rendering content[] directly.
+ */
+export interface GenericDisplayData {
+    type: 'generic';
+}
+/**
+ * Type guard for DiffDisplayData.
+ */
+export declare function isDiffDisplay(d: ToolDisplayData): d is DiffDisplayData;
+/**
+ * Type guard for ShellDisplayData.
+ */
+export declare function isShellDisplay(d: ToolDisplayData): d is ShellDisplayData;
+/**
+ * Type guard for SearchDisplayData.
+ */
+export declare function isSearchDisplay(d: ToolDisplayData): d is SearchDisplayData;
+/**
+ * Type guard for FileDisplayData.
+ */
+export declare function isFileDisplay(d: ToolDisplayData): d is FileDisplayData;
+/**
+ * Type guard for GenericDisplayData.
+ */
+export declare function isGenericDisplay(d: ToolDisplayData): d is GenericDisplayData;
+/**
+ * Validates that an unknown value is a valid ToolDisplayData.
+ * Used by sanitizer to safely extract _display from tool results.
+ */
+export declare function isValidDisplayData(d: unknown): d is ToolDisplayData;
+//# sourceMappingURL=display-types.d.ts.map

package/dist/tools/display-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"display-types.d.ts","sourceRoot":"","sources":["../../src/tools/display-types.ts"],"names":[],"mappings":"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"}

package/dist/tools/display-types.js

@@ -0,0 +1,32 @@
+import "../chunk-PTJYTZNU.js";
+function isDiffDisplay(d) {
+  return d.type === "diff";
+}
+function isShellDisplay(d) {
+  return d.type === "shell";
+}
+function isSearchDisplay(d) {
+  return d.type === "search";
+}
+function isFileDisplay(d) {
+  return d.type === "file";
+}
+function isGenericDisplay(d) {
+  return d.type === "generic";
+}
+const VALID_DISPLAY_TYPES = ["diff", "shell", "search", "file", "generic"];
+function isValidDisplayData(d) {
+  if (d === null || typeof d !== "object") {
+    return false;
+  }
+  const obj = d;
+  return typeof obj.type === "string" && VALID_DISPLAY_TYPES.includes(obj.type);
+}
+export {
+  isDiffDisplay,
+  isFileDisplay,
+  isGenericDisplay,
+  isSearchDisplay,
+  isShellDisplay,
+  isValidDisplayData
+};

package/dist/tools/error-codes.cjs

@@ -25,6 +25,7 @@ var ToolErrorCode = /* @__PURE__ */ ((ToolErrorCode2) => {
   ToolErrorCode2["EXECUTION_DENIED"] = "tools_execution_denied";
   ToolErrorCode2["EXECUTION_TIMEOUT"] = "tools_execution_timeout";
   ToolErrorCode2["EXECUTION_FAILED"] = "tools_execution_failed";
+  ToolErrorCode2["VALIDATION_FAILED"] = "tools_validation_failed";
   ToolErrorCode2["CONFIRMATION_HANDLER_MISSING"] = "tools_confirmation_handler_missing";
   ToolErrorCode2["CONFIRMATION_TIMEOUT"] = "tools_confirmation_timeout";
   ToolErrorCode2["CONFIRMATION_CANCELLED"] = "tools_confirmation_cancelled";
@@ -32,6 +33,7 @@ var ToolErrorCode = /* @__PURE__ */ ((ToolErrorCode2) => {
   ToolErrorCode2["TOOL_INVALID_ARGS"] = "tools_invalid_args";
   ToolErrorCode2["TOOL_UNAUTHORIZED"] = "tools_unauthorized";
   ToolErrorCode2["CONFIG_INVALID"] = "tools_config_invalid";
+  ToolErrorCode2["FEATURE_DISABLED"] = "tools_feature_disabled";
   return ToolErrorCode2;
 })(ToolErrorCode || {});
 // Annotate the CommonJS export names for ESM import in node:

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

@@ -6,12 +6,14 @@ export declare enum ToolErrorCode {
     EXECUTION_DENIED = "tools_execution_denied",
     EXECUTION_TIMEOUT = "tools_execution_timeout",
     EXECUTION_FAILED = "tools_execution_failed",
+    VALIDATION_FAILED = "tools_validation_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"
+    CONFIG_INVALID = "tools_config_invalid",
+    FEATURE_DISABLED = "tools_feature_disabled"
 }
 //# sourceMappingURL=error-codes.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"error-codes.d.ts","sourceRoot":"","sources":["../../src/tools/error-codes.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,oBAAY,aAAa;IAErB,gBAAgB,2BAA2B;IAC3C,iBAAiB,4BAA4B;IAC7C,gBAAgB,2BAA2B;IAG3C,4BAA4B,uCAAuC;IACnE,oBAAoB,+BAA+B;IACnD,sBAAsB,iCAAiC;IAGvD,cAAc,yBAAyB;IACvC,iBAAiB,uBAAuB;IACxC,iBAAiB,uBAAuB;IAGxC,cAAc,yBAAyB;CAC1C"}
+{"version":3,"file":"error-codes.d.ts","sourceRoot":"","sources":["../../src/tools/error-codes.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,oBAAY,aAAa;IAErB,gBAAgB,2BAA2B;IAC3C,iBAAiB,4BAA4B;IAC7C,gBAAgB,2BAA2B;IAG3C,iBAAiB,4BAA4B;IAG7C,4BAA4B,uCAAuC;IACnE,oBAAoB,+BAA+B;IACnD,sBAAsB,iCAAiC;IAGvD,cAAc,yBAAyB;IACvC,iBAAiB,uBAAuB;IACxC,iBAAiB,uBAAuB;IAGxC,cAAc,yBAAyB;IACvC,gBAAgB,2BAA2B;CAC9C"}