@dexto/core 1.4.0 → 1.5.1

package/dist/tools/internal-tools/implementations/get-resource-tool.js

@@ -0,0 +1,90 @@
+import "../../../chunk-PTJYTZNU.js";
+import { z } from "zod";
+const GetResourceInputSchema = z.object({
+  reference: z.string().describe(
+    'The resource reference to access. Formats: "blob:abc123" (from list_resources), "resource_ref:blob:abc123" (from tool annotations)'
+  ),
+  format: z.enum(["url", "metadata"]).default("url").describe(
+    'Output format: "url" for a shareable URL (requires remote storage like Supabase), "metadata" for resource information without loading the data'
+  )
+}).strict();
+function createGetResourceTool(resourceManager) {
+  return {
+    id: "get_resource",
+    description: 'Access a stored resource. Use format "url" to get a shareable URL for other agents or external systems (requires remote storage like Supabase). Use format "metadata" to get resource information without loading data. References can be obtained from tool result annotations or list_resources.',
+    inputSchema: GetResourceInputSchema,
+    execute: async (input, _context) => {
+      const { reference, format } = input;
+      try {
+        const blobStore = resourceManager.getBlobStore();
+        const storeType = blobStore.getStoreType();
+        let blobUri = reference;
+        if (blobUri.startsWith("resource_ref:")) {
+          blobUri = blobUri.substring("resource_ref:".length);
+        }
+        if (blobUri.startsWith("@")) {
+          blobUri = blobUri.substring(1);
+        }
+        if (!blobUri.startsWith("blob:")) {
+          blobUri = `blob:${blobUri}`;
+        }
+        const exists = await blobStore.exists(blobUri);
+        if (!exists) {
+          return {
+            success: false,
+            error: `Resource not found: ${reference}`,
+            _hint: "Use list_resources to see available resources"
+          };
+        }
+        if (format === "metadata") {
+          const allBlobs = await blobStore.listBlobs();
+          const blobRef = allBlobs.find((b) => b.uri === blobUri);
+          if (!blobRef) {
+            return {
+              success: false,
+              error: `Resource metadata not found: ${reference}`,
+              _hint: "Use list_resources to see available resources"
+            };
+          }
+          return {
+            success: true,
+            format: "metadata",
+            reference: blobUri,
+            mimeType: blobRef.metadata.mimeType,
+            size: blobRef.metadata.size,
+            filename: blobRef.metadata.originalName,
+            source: blobRef.metadata.source,
+            createdAt: blobRef.metadata.createdAt.toISOString()
+          };
+        }
+        if (storeType === "memory" || storeType === "local") {
+          return {
+            success: false,
+            error: "URL generation not available with local/memory storage",
+            _hint: "Configure remote storage (e.g., Supabase) in your agent config to enable URL sharing. Local storage cannot generate shareable URLs.",
+            storeType
+          };
+        }
+        const blob = await blobStore.retrieve(blobUri, "url");
+        return {
+          success: true,
+          format: "url",
+          url: blob.data,
+          reference: blobUri,
+          mimeType: blob.metadata.mimeType,
+          size: blob.metadata.size,
+          filename: blob.metadata.originalName
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          success: false,
+          error: `Failed to access resource: ${message}`
+        };
+      }
+    }
+  };
+}
+export {
+  createGetResourceTool
+};

package/dist/tools/internal-tools/implementations/list-resources-tool.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 list_resources_tool_exports = {};
+__export(list_resources_tool_exports, {
+  createListResourcesTool: () => createListResourcesTool
+});
+module.exports = __toCommonJS(list_resources_tool_exports);
+var import_zod = require("zod");
+const ListResourcesInputSchema = import_zod.z.object({
+  source: import_zod.z.enum(["all", "tool", "user"]).optional().default("all").describe(
+    'Filter by source: "tool" for tool-generated resources, "user" for user-uploaded, "all" for both'
+  ),
+  kind: import_zod.z.enum(["all", "image", "audio", "video", "binary"]).optional().default("all").describe('Filter by type: "image", "audio", "video", "binary", or "all"'),
+  limit: import_zod.z.number().optional().default(50).describe("Maximum number of resources to return (default: 50)")
+}).strict();
+function createListResourcesTool(resourceManager) {
+  return {
+    id: "list_resources",
+    description: "List available resources (images, files, etc.). Returns resource references that can be used with get_resource to obtain shareable URLs or metadata. Filter by source (tool/user) or kind (image/audio/video/binary).",
+    inputSchema: ListResourcesInputSchema,
+    execute: async (input, _context) => {
+      const { source, kind, limit } = input;
+      try {
+        const blobStore = resourceManager.getBlobStore();
+        const allBlobs = await blobStore.listBlobs();
+        const resources = [];
+        for (const blob of allBlobs) {
+          if (blob.metadata.source === "system") {
+            continue;
+          }
+          if (source !== "all" && blob.metadata.source !== source) {
+            continue;
+          }
+          const mimeType = blob.metadata.mimeType;
+          let resourceKind = "binary";
+          if (mimeType.startsWith("image/")) resourceKind = "image";
+          else if (mimeType.startsWith("audio/")) resourceKind = "audio";
+          else if (mimeType.startsWith("video/")) resourceKind = "video";
+          if (kind !== "all" && resourceKind !== kind) {
+            continue;
+          }
+          resources.push({
+            reference: blob.uri,
+            kind: resourceKind,
+            mimeType: blob.metadata.mimeType,
+            ...blob.metadata.originalName && { filename: blob.metadata.originalName },
+            source: blob.metadata.source || "tool",
+            size: blob.metadata.size,
+            createdAt: blob.metadata.createdAt.toISOString()
+          });
+        }
+        resources.sort(
+          (a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()
+        );
+        const limitedResources = resources.slice(0, limit);
+        return {
+          success: true,
+          count: limitedResources.length,
+          resources: limitedResources,
+          _hint: limitedResources.length > 0 ? "Use get_resource with a reference to get a shareable URL or metadata" : "No resources found matching the criteria"
+        };
+      } catch (error) {
+        return {
+          success: false,
+          error: `Failed to list resources: ${error instanceof Error ? error.message : String(error)}`,
+          resources: []
+        };
+      }
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createListResourcesTool
+});

package/dist/tools/internal-tools/implementations/list-resources-tool.d.ts

@@ -0,0 +1,24 @@
+import { InternalTool } from '../../types.js';
+import type { ResourceManager } from '../../../resources/manager.js';
+/**
+ * Internal tool for listing available resources.
+ *
+ * This tool allows agents to discover what resources (images, files, etc.) are
+ * available. Use this to find resources that can be accessed with get_resource.
+ *
+ * Resources are stored blobs from:
+ * - Tool results (images generated by tools, screenshots, etc.)
+ * - User uploads (files attached to messages)
+ *
+ * @example
+ * ```typescript
+ * // List all tool-generated images
+ * list_resources({ source: 'tool', kind: 'image' })
+ * → { resources: [{ reference: 'blob:abc123', kind: 'image', ... }] }
+ *
+ * // Get a URL for sharing
+ * get_resource({ reference: 'blob:abc123', format: 'url' })
+ * ```
+ */
+export declare function createListResourcesTool(resourceManager: ResourceManager): InternalTool;
+//# sourceMappingURL=list-resources-tool.d.ts.map

package/dist/tools/internal-tools/implementations/list-resources-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-resources-tool.d.ts","sourceRoot":"","sources":["../../../../src/tools/internal-tools/implementations/list-resources-tool.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAwB,MAAM,gBAAgB,CAAC;AACpE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAqDrE;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,uBAAuB,CAAC,eAAe,EAAE,eAAe,GAAG,YAAY,CA8EtF"}

package/dist/tools/internal-tools/implementations/list-resources-tool.js

@@ -0,0 +1,68 @@
+import "../../../chunk-PTJYTZNU.js";
+import { z } from "zod";
+const ListResourcesInputSchema = z.object({
+  source: z.enum(["all", "tool", "user"]).optional().default("all").describe(
+    'Filter by source: "tool" for tool-generated resources, "user" for user-uploaded, "all" for both'
+  ),
+  kind: z.enum(["all", "image", "audio", "video", "binary"]).optional().default("all").describe('Filter by type: "image", "audio", "video", "binary", or "all"'),
+  limit: z.number().optional().default(50).describe("Maximum number of resources to return (default: 50)")
+}).strict();
+function createListResourcesTool(resourceManager) {
+  return {
+    id: "list_resources",
+    description: "List available resources (images, files, etc.). Returns resource references that can be used with get_resource to obtain shareable URLs or metadata. Filter by source (tool/user) or kind (image/audio/video/binary).",
+    inputSchema: ListResourcesInputSchema,
+    execute: async (input, _context) => {
+      const { source, kind, limit } = input;
+      try {
+        const blobStore = resourceManager.getBlobStore();
+        const allBlobs = await blobStore.listBlobs();
+        const resources = [];
+        for (const blob of allBlobs) {
+          if (blob.metadata.source === "system") {
+            continue;
+          }
+          if (source !== "all" && blob.metadata.source !== source) {
+            continue;
+          }
+          const mimeType = blob.metadata.mimeType;
+          let resourceKind = "binary";
+          if (mimeType.startsWith("image/")) resourceKind = "image";
+          else if (mimeType.startsWith("audio/")) resourceKind = "audio";
+          else if (mimeType.startsWith("video/")) resourceKind = "video";
+          if (kind !== "all" && resourceKind !== kind) {
+            continue;
+          }
+          resources.push({
+            reference: blob.uri,
+            kind: resourceKind,
+            mimeType: blob.metadata.mimeType,
+            ...blob.metadata.originalName && { filename: blob.metadata.originalName },
+            source: blob.metadata.source || "tool",
+            size: blob.metadata.size,
+            createdAt: blob.metadata.createdAt.toISOString()
+          });
+        }
+        resources.sort(
+          (a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()
+        );
+        const limitedResources = resources.slice(0, limit);
+        return {
+          success: true,
+          count: limitedResources.length,
+          resources: limitedResources,
+          _hint: limitedResources.length > 0 ? "Use get_resource with a reference to get a shareable URL or metadata" : "No resources found matching the criteria"
+        };
+      } catch (error) {
+        return {
+          success: false,
+          error: `Failed to list resources: ${error instanceof Error ? error.message : String(error)}`,
+          resources: []
+        };
+      }
+    }
+  };
+}
+export {
+  createListResourcesTool
+};

package/dist/tools/internal-tools/provider.cjs

@@ -24,31 +24,59 @@ module.exports = __toCommonJS(provider_exports);
 var import_errors = require("../errors.js");
 var import_schema = require("../../utils/schema.js");
 var import_registry = require("./registry.js");
+var import_custom_tool_registry = require("../custom-tool-registry.js");
+var import_DextoRuntimeError = require("../../errors/DextoRuntimeError.js");
+var import_error_codes = require("../error-codes.js");
 class InternalToolsProvider {
   services;
-  tools = /* @__PURE__ */ new Map();
-  // ← Store original InternalTool
+  internalTools = /* @__PURE__ */ new Map();
+  // Built-in internal tools
+  customTools = /* @__PURE__ */ new Map();
+  // Custom tool provider tools
   config;
+  customToolConfigs;
   logger;
-  constructor(services, config = [], logger) {
+  agent;
+  // Set after construction to avoid circular dependency
+  constructor(services, config = [], customToolConfigs = [], logger) {
     this.services = services;
     this.config = config;
+    this.customToolConfigs = customToolConfigs;
     this.logger = logger;
-    this.logger.debug("InternalToolsProvider initialized with config:", { config });
+    this.logger.debug("InternalToolsProvider initialized with config:", {
+      config,
+      customToolConfigs
+    });
+  }
+  /**
+   * Set agent reference after construction (avoids circular dependency)
+   * Must be called before initialize() if custom tools need agent access
+   */
+  setAgent(agent) {
+    this.agent = agent;
   }
   /**
    * Initialize the internal tools provider by registering all available internal tools
+   * and custom tools from the registry
    */
   async initialize() {
     this.logger.info("Initializing InternalToolsProvider...");
     try {
-      if (this.config.length === 0) {
+      if (this.config.length > 0) {
+        this.registerInternalTools();
+      } else {
         this.logger.info("No internal tools enabled by configuration");
-        return;
       }
-      this.registerInternalTools();
-      const toolCount = this.tools.size;
-      this.logger.info(`InternalToolsProvider initialized with ${toolCount} internal tools`);
+      if (this.customToolConfigs.length > 0) {
+        this.registerCustomTools();
+      } else {
+        this.logger.debug("No custom tool providers configured");
+      }
+      const internalCount = this.internalTools.size;
+      const customCount = this.customTools.size;
+      this.logger.info(
+        `InternalToolsProvider initialized with ${internalCount + customCount} tools (${internalCount} internal, ${customCount} custom)`
+      );
     } catch (error) {
       this.logger.error(
         `Failed to initialize InternalToolsProvider: ${error instanceof Error ? error.message : String(error)}`
@@ -86,7 +114,7 @@ class InternalToolsProvider {
       }
       try {
         const tool = toolInfo.factory(this.services);
-        this.tools.set(toolName, tool);
+        this.internalTools.set(toolName, tool);
         this.logger.debug(`Registered ${toolName} internal tool`);
       } catch (error) {
         this.logger.error(
@@ -96,27 +124,92 @@ class InternalToolsProvider {
     }
   }
   /**
-   * Check if a tool exists
+   * Register custom tools from the custom tool registry.
+   * Tools are stored by their original ID - prefixing is handled by ToolManager.
+   */
+  registerCustomTools() {
+    if (!this.agent) {
+      throw import_errors.ToolError.configInvalid(
+        "Agent reference not set. Call setAgent() before initialize() when using custom tools."
+      );
+    }
+    const context = {
+      logger: this.logger,
+      agent: this.agent,
+      services: {
+        ...this.services,
+        // Include storageManager from agent services for custom tools that need persistence
+        storageManager: this.agent.services?.storageManager
+      }
+    };
+    for (const toolConfig of this.customToolConfigs) {
+      try {
+        const validatedConfig = import_custom_tool_registry.customToolRegistry.validateConfig(toolConfig);
+        const provider = import_custom_tool_registry.customToolRegistry.get(validatedConfig.type);
+        if (!provider) {
+          const availableTypes = import_custom_tool_registry.customToolRegistry.getTypes();
+          throw import_errors.ToolError.unknownCustomToolProvider(validatedConfig.type, availableTypes);
+        }
+        const tools = provider.create(validatedConfig, context);
+        for (const tool of tools) {
+          if (this.customTools.has(tool.id)) {
+            this.logger.warn(
+              `Custom tool '${tool.id}' conflicts with existing custom tool. Skipping.`
+            );
+            continue;
+          }
+          this.customTools.set(tool.id, tool);
+          this.logger.debug(
+            `Registered custom tool: ${tool.id} from provider '${provider.metadata?.displayName || validatedConfig.type}'`
+          );
+        }
+      } catch (error) {
+        if (error instanceof import_DextoRuntimeError.DextoRuntimeError && error.code === import_error_codes.ToolErrorCode.CUSTOM_TOOL_PROVIDER_UNKNOWN) {
+          throw error;
+        }
+        this.logger.error(
+          `Failed to register custom tool provider: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  }
+  /**
+   * Check if a tool exists (checks both internal and custom tools)
    */
   hasTool(toolName) {
-    return this.tools.has(toolName);
+    return this.internalTools.has(toolName) || this.customTools.has(toolName);
+  }
+  /**
+   * Check if an internal tool exists
+   */
+  hasInternalTool(toolName) {
+    return this.internalTools.has(toolName);
+  }
+  /**
+   * Check if a custom tool exists
+   */
+  hasCustomTool(toolName) {
+    return this.customTools.has(toolName);
   }
   /**
    * Get an internal tool by name
    * Returns undefined if tool doesn't exist
    */
   getTool(toolName) {
-    return this.tools.get(toolName);
+    return this.internalTools.get(toolName) || this.customTools.get(toolName);
   }
   /**
    * Execute an internal tool - confirmation is handled by ToolManager
    */
   async executeTool(toolName, args, sessionId, abortSignal) {
-    const tool = this.tools.get(toolName);
+    const tool = this.internalTools.get(toolName) || this.customTools.get(toolName);
     if (!tool) {
-      this.logger.error(`\u274C No internal tool found: ${toolName}`);
+      this.logger.error(`\u274C No tool found: ${toolName}`);
       this.logger.debug(
-        `Available internal tools: ${Array.from(this.tools.keys()).join(", ")}`
+        `Available internal tools: ${Array.from(this.internalTools.keys()).join(", ")}`
+      );
+      this.logger.debug(
+        `Available custom tools: ${Array.from(this.customTools.keys()).join(", ")}`
       );
       throw import_errors.ToolError.notFound(toolName);
     }
@@ -145,31 +238,68 @@ class InternalToolsProvider {
     }
   }
   /**
-   * Get all tools in ToolSet format with on-demand JSON Schema conversion
+   * Get internal tools in ToolSet format (excludes custom tools)
+   */
+  getInternalTools() {
+    const toolSet = {};
+    for (const [name, tool] of this.internalTools) {
+      toolSet[name] = {
+        name: tool.id,
+        description: tool.description,
+        parameters: (0, import_schema.convertZodSchemaToJsonSchema)(tool.inputSchema, this.logger)
+      };
+    }
+    return toolSet;
+  }
+  /**
+   * Get custom tools in ToolSet format (excludes internal tools)
    */
-  getAllTools() {
+  getCustomTools() {
     const toolSet = {};
-    for (const [name, tool] of this.tools) {
+    for (const [name, tool] of this.customTools) {
       toolSet[name] = {
         name: tool.id,
         description: tool.description,
         parameters: (0, import_schema.convertZodSchemaToJsonSchema)(tool.inputSchema, this.logger)
-        // ← Convert on-demand
       };
     }
     return toolSet;
   }
   /**
-   * Get tool names
+   * Get internal tool names
+   */
+  getInternalToolNames() {
+    return Array.from(this.internalTools.keys());
+  }
+  /**
+   * Get custom tool names
+   */
+  getCustomToolNames() {
+    return Array.from(this.customTools.keys());
+  }
+  /**
+   * Get all tool names (internal + custom)
    */
   getToolNames() {
-    return Array.from(this.tools.keys());
+    return [...this.internalTools.keys(), ...this.customTools.keys()];
   }
   /**
    * Get tool count
    */
   getToolCount() {
-    return this.tools.size;
+    return this.internalTools.size + this.customTools.size;
+  }
+  /**
+   * Get internal tool count
+   */
+  getInternalToolCount() {
+    return this.internalTools.size;
+  }
+  /**
+   * Get custom tool count
+   */
+  getCustomToolCount() {
+    return this.customTools.size;
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/tools/internal-tools/provider.d.ts

@@ -1,27 +1,39 @@
 import { ToolSet, InternalTool } from '../types.js';
 import type { IDextoLogger } from '../../logger/v2/types.js';
+import type { DextoAgent } from '../../agent/DextoAgent.js';
 import { InternalToolsServices } from './registry.js';
-import type { InternalToolsConfig } from '../schemas.js';
+import type { InternalToolsConfig, CustomToolsConfig } from '../schemas.js';
 /**
- * Provider for built-in internal tools that are part of the core system
+ * Provider for built-in internal tools and custom tool providers
  *
- * This provider manages internal tools that are shipped with the core system
- * and need access to core services like SearchService, SessionManager, etc.
+ * This provider manages:
+ * 1. Built-in internal tools that are shipped with the core system
+ * 2. Custom tools registered via the customToolRegistry
  *
  * Benefits:
  * - Clean separation: ToolManager doesn't need to know about specific services
  * - Easy to extend: Just add new tools and services as needed
  * - Lightweight: Direct tool management without complex infrastructure
  * - No unnecessary ProcessedInternalTool wrapper - uses InternalTool directly
+ * - Custom tools follow the same provider pattern as blob storage
  */
 export declare class InternalToolsProvider {
     private services;
-    private tools;
+    private internalTools;
+    private customTools;
     private config;
+    private customToolConfigs;
     private logger;
-    constructor(services: InternalToolsServices, config: InternalToolsConfig | undefined, logger: IDextoLogger);
+    private agent?;
+    constructor(services: InternalToolsServices, config: InternalToolsConfig | undefined, customToolConfigs: CustomToolsConfig | undefined, logger: IDextoLogger);
+    /**
+     * Set agent reference after construction (avoids circular dependency)
+     * Must be called before initialize() if custom tools need agent access
+     */
+    setAgent(agent: DextoAgent): void;
     /**
      * Initialize the internal tools provider by registering all available internal tools
+     * and custom tools from the registry
      */
     initialize(): Promise<void>;
     /**
@@ -29,9 +41,22 @@ export declare class InternalToolsProvider {
      */
     private registerInternalTools;
     /**
-     * Check if a tool exists
+     * Register custom tools from the custom tool registry.
+     * Tools are stored by their original ID - prefixing is handled by ToolManager.
+     */
+    private registerCustomTools;
+    /**
+     * Check if a tool exists (checks both internal and custom tools)
      */
     hasTool(toolName: string): boolean;
+    /**
+     * Check if an internal tool exists
+     */
+    hasInternalTool(toolName: string): boolean;
+    /**
+     * Check if a custom tool exists
+     */
+    hasCustomTool(toolName: string): boolean;
     /**
      * Get an internal tool by name
      * Returns undefined if tool doesn't exist
@@ -42,16 +67,36 @@ export declare class InternalToolsProvider {
      */
     executeTool(toolName: string, args: Record<string, unknown>, sessionId?: string, abortSignal?: AbortSignal): Promise<unknown>;
     /**
-     * Get all tools in ToolSet format with on-demand JSON Schema conversion
+     * Get internal tools in ToolSet format (excludes custom tools)
+     */
+    getInternalTools(): ToolSet;
+    /**
+     * Get custom tools in ToolSet format (excludes internal tools)
+     */
+    getCustomTools(): ToolSet;
+    /**
+     * Get internal tool names
+     */
+    getInternalToolNames(): string[];
+    /**
+     * Get custom tool names
      */
-    getAllTools(): ToolSet;
+    getCustomToolNames(): string[];
     /**
-     * Get tool names
+     * Get all tool names (internal + custom)
      */
     getToolNames(): string[];
     /**
      * Get tool count
      */
     getToolCount(): number;
+    /**
+     * Get internal tool count
+     */
+    getInternalToolCount(): number;
+    /**
+     * Get custom tool count
+     */
+    getCustomToolCount(): number;
 }
 //# sourceMappingURL=provider.d.ts.map

package/dist/tools/internal-tools/provider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../../../src/tools/internal-tools/provider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAwB,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC1E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAG7D,OAAO,EAAE,qBAAqB,EAA0C,MAAM,eAAe,CAAC;AAC9F,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAEzD;;;;;;;;;;;GAWG;AACH,qBAAa,qBAAqB;IAC9B,OAAO,CAAC,QAAQ,CAAwB;IACxC,OAAO,CAAC,KAAK,CAAwC;IACrD,OAAO,CAAC,MAAM,CAAsB;IACpC,OAAO,CAAC,MAAM,CAAe;gBAGzB,QAAQ,EAAE,qBAAqB,EAC/B,MAAM,EAAE,mBAAmB,YAAK,EAChC,MAAM,EAAE,YAAY;IAQxB;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAsBjC;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAgD7B;;OAEG;IACH,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAIlC;;;OAGG;IACH,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS;IAInD;;OAEG;IACG,WAAW,CACb,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,SAAS,CAAC,EAAE,MAAM,EAClB,WAAW,CAAC,EAAE,WAAW,GAC1B,OAAO,CAAC,OAAO,CAAC;IAqCnB;;OAEG;IACH,WAAW,IAAI,OAAO;IActB;;OAEG;IACH,YAAY,IAAI,MAAM,EAAE;IAIxB;;OAEG;IACH,YAAY,IAAI,MAAM;CAGzB"}
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../../../src/tools/internal-tools/provider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAwB,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC1E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAG5D,OAAO,EAAE,qBAAqB,EAA0C,MAAM,eAAe,CAAC;AAC9F,OAAO,KAAK,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAK5E;;;;;;;;;;;;;GAaG;AACH,qBAAa,qBAAqB;IAC9B,OAAO,CAAC,QAAQ,CAAwB;IACxC,OAAO,CAAC,aAAa,CAAwC;IAC7D,OAAO,CAAC,WAAW,CAAwC;IAC3D,OAAO,CAAC,MAAM,CAAsB;IACpC,OAAO,CAAC,iBAAiB,CAAoB;IAC7C,OAAO,CAAC,MAAM,CAAe;IAC7B,OAAO,CAAC,KAAK,CAAC,CAAa;gBAGvB,QAAQ,EAAE,qBAAqB,EAC/B,MAAM,EAAE,mBAAmB,YAAK,EAChC,iBAAiB,EAAE,iBAAiB,YAAK,EACzC,MAAM,EAAE,YAAY;IAYxB;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI;IAIjC;;;OAGG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IA+BjC;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAgD7B;;;OAGG;IACH,OAAO,CAAC,mBAAmB;IAgE3B;;OAEG;IACH,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAIlC;;OAEG;IACH,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAI1C;;OAEG;IACH,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAIxC;;;OAGG;IACH,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS;IAInD;;OAEG;IACG,WAAW,CACb,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,SAAS,CAAC,EAAE,MAAM,EAClB,WAAW,CAAC,EAAE,WAAW,GAC1B,OAAO,CAAC,OAAO,CAAC;IAyCnB;;OAEG;IACH,gBAAgB,IAAI,OAAO;IAc3B;;OAEG;IACH,cAAc,IAAI,OAAO;IAczB;;OAEG;IACH,oBAAoB,IAAI,MAAM,EAAE;IAIhC;;OAEG;IACH,kBAAkB,IAAI,MAAM,EAAE;IAI9B;;OAEG;IACH,YAAY,IAAI,MAAM,EAAE;IAIxB;;OAEG;IACH,YAAY,IAAI,MAAM;IAItB;;OAEG;IACH,oBAAoB,IAAI,MAAM;IAI9B;;OAEG;IACH,kBAAkB,IAAI,MAAM;CAG/B"}