@dexto/core 1.5.7 → 1.6.0

package/dist/tools/custom-tool-registry.d.ts

@@ -1,126 +0,0 @@
-import type { InternalTool } from './types.js';
-import type { IDextoLogger } from '../logger/v2/types.js';
-import type { DextoAgent } from '../agent/DextoAgent.js';
-import { z } from 'zod';
-import { BaseRegistry } from '../providers/base-registry.js';
-/**
- * Context passed to custom tool providers when creating tools.
- * Provides access to the agent instance for bidirectional communication.
- *
- * **Bidirectional Services Pattern:**
- * Some services need both:
- * - Agent → Service: LLM calls tools that invoke service methods
- * - Service → Agent: Service emits events that trigger agent invocation
- *
- * Implementation pattern:
- * ```typescript
- * create: (config, context) => {
- *     const service = new MyService(config, context.logger);
- *
- *     // Wire up Service → Agent communication
- *     service.on('event', async (data) => {
- *         await context.agent.sendMessage({
- *             role: 'user',
- *             content: data.prompt,
- *         });
- *     });
- *
- *     // Return Agent → Service tools
- *     return [createMyTool(service)];
- * }
- * ```
- *
- * **Future Consideration:**
- * For complex event routing or decoupled architectures, consider using an Event Bus pattern
- * where services emit events to a central bus and the agent/app subscribes. This would
- * provide better separation of concerns at the cost of more indirection and complexity.
- */
-export interface ToolCreationContext {
-    logger: IDextoLogger;
-    agent: DextoAgent;
-    /**
-     * Optional services available to custom tool providers.
-     *
-     * Core services (provided by agent):
-     * - approvalManager: For tools that need approval flows
-     * - storageManager: For tools that need persistence
-     * - resourceManager: For tools that need resource access
-     * - searchService: For tools that need search capabilities
-     *
-     * External tool providers can add their own services using the index signature.
-     */
-    services?: {
-        searchService?: any;
-        approvalManager?: any;
-        resourceManager?: any;
-        storageManager?: import('../storage/index.js').StorageManager;
-        [key: string]: any;
-    };
-}
-/**
- * Custom tool provider interface.
- * Allows external code to register tool providers that create one or more tools.
- * Mirrors the BlobStoreProvider pattern for consistency.
- *
- * @template TType - The provider type discriminator (must match config.type)
- * @template TConfig - The provider configuration type (must include { type: TType })
- */
-export interface CustomToolProvider<TType extends string = string, TConfig extends {
-    type: TType;
-} = any> {
-    /** Unique type identifier matching the discriminator in config */
-    type: TType;
-    /** Zod schema for runtime validation of provider configuration */
-    configSchema: z.ZodType<TConfig, any, any>;
-    /**
-     * Factory function to create tools from validated configuration
-     * @param config - Validated configuration matching configSchema
-     * @param context - Tool creation context with logger and optional services
-     * @returns Array of tools to register
-     */
-    create(config: TConfig, context: ToolCreationContext): InternalTool[];
-    /** Optional metadata for display and categorization */
-    metadata?: {
-        displayName: string;
-        description: string;
-        category?: string;
-    };
-}
-/**
- * Registry for custom tool providers.
- * Mirrors BlobStoreRegistry pattern for consistency across Dexto provider system.
- *
- * Custom tool providers can be registered from external code (CLI, apps, examples)
- * and are validated at runtime using their Zod schemas.
- *
- * Extends BaseRegistry for common registry functionality.
- *
- * When a provider is registered, its config schema is also registered in the
- * customToolSchemaRegistry for early validation at config load time.
- */
-export declare class CustomToolRegistry extends BaseRegistry<CustomToolProvider> {
-    constructor();
-    /**
-     * Register a custom tool provider.
-     * Also registers the provider's config schema for early validation.
-     *
-     * @param provider - The custom tool provider to register
-     * @throws Error if a provider with the same type is already registered
-     */
-    register(provider: CustomToolProvider): void;
-    /**
-     * Unregister a custom tool provider.
-     * Note: This does NOT unregister the schema from customToolSchemaRegistry
-     * to avoid breaking active configs that reference the schema.
-     *
-     * @param type - The provider type to unregister
-     * @returns true if the provider was unregistered, false if it wasn't registered
-     */
-    unregister(type: string): boolean;
-}
-/**
- * Global singleton instance of the custom tool registry.
- * Custom tool providers should be registered at application startup.
- */
-export declare const customToolRegistry: CustomToolRegistry;
-//# sourceMappingURL=custom-tool-registry.d.ts.map

package/dist/tools/custom-tool-registry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"custom-tool-registry.d.ts","sourceRoot":"","sources":["../../src/tools/custom-tool-registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAC1D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AACzD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,YAAY,EAA6B,MAAM,+BAA+B,CAAC;AAGxF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,MAAM,WAAW,mBAAmB;IAChC,MAAM,EAAE,YAAY,CAAC;IACrB,KAAK,EAAE,UAAU,CAAC;IAClB;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,EAAE;QACP,aAAa,CAAC,EAAE,GAAG,CAAC;QACpB,eAAe,CAAC,EAAE,GAAG,CAAC;QACtB,eAAe,CAAC,EAAE,GAAG,CAAC;QACtB,cAAc,CAAC,EAAE,OAAO,qBAAqB,EAAE,cAAc,CAAC;QAC9D,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;KACtB,CAAC;CACL;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,kBAAkB,CAC/B,KAAK,SAAS,MAAM,GAAG,MAAM,EAC7B,OAAO,SAAS;IAAE,IAAI,EAAE,KAAK,CAAA;CAAE,GAAG,GAAG;IAErC,kEAAkE;IAClE,IAAI,EAAE,KAAK,CAAC;IAEZ,kEAAkE;IAClE,YAAY,EAAE,CAAC,CAAC,OAAO,CAAC,OAAO,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;IAE3C;;;;;OAKG;IACH,MAAM,CAAC,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,mBAAmB,GAAG,YAAY,EAAE,CAAC;IAEtE,uDAAuD;IACvD,QAAQ,CAAC,EAAE;QACP,WAAW,EAAE,MAAM,CAAC;QACpB,WAAW,EAAE,MAAM,CAAC;QACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;KACrB,CAAC;CACL;AAYD;;;;;;;;;;;GAWG;AACH,qBAAa,kBAAmB,SAAQ,YAAY,CAAC,kBAAkB,CAAC;;IAKpE;;;;;;OAMG;IACM,QAAQ,CAAC,QAAQ,EAAE,kBAAkB,GAAG,IAAI;IAQrD;;;;;;;OAOG;IACM,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;CAK7C;AAED;;;GAGG;AACH,eAAO,MAAM,kBAAkB,oBAA2B,CAAC"}

package/dist/tools/custom-tool-registry.js

@@ -1,40 +0,0 @@
-import "../chunk-PTJYTZNU.js";
-import { ToolError } from "./errors.js";
-import { BaseRegistry } from "../providers/base-registry.js";
-import { customToolSchemaRegistry } from "./custom-tool-schema-registry.js";
-const customToolErrorFactory = {
-  alreadyRegistered: (type) => ToolError.customToolProviderAlreadyRegistered(type),
-  notFound: (type, availableTypes) => ToolError.unknownCustomToolProvider(type, availableTypes)
-};
-class CustomToolRegistry extends BaseRegistry {
-  constructor() {
-    super(customToolErrorFactory);
-  }
-  /**
-   * Register a custom tool provider.
-   * Also registers the provider's config schema for early validation.
-   *
-   * @param provider - The custom tool provider to register
-   * @throws Error if a provider with the same type is already registered
-   */
-  register(provider) {
-    super.register(provider);
-    customToolSchemaRegistry.register(provider.type, provider.configSchema);
-  }
-  /**
-   * Unregister a custom tool provider.
-   * Note: This does NOT unregister the schema from customToolSchemaRegistry
-   * to avoid breaking active configs that reference the schema.
-   *
-   * @param type - The provider type to unregister
-   * @returns true if the provider was unregistered, false if it wasn't registered
-   */
-  unregister(type) {
-    return super.unregister(type);
-  }
-}
-const customToolRegistry = new CustomToolRegistry();
-export {
-  CustomToolRegistry,
-  customToolRegistry
-};

package/dist/tools/custom-tool-schema-registry.cjs

@@ -1,164 +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 custom_tool_schema_registry_exports = {};
-__export(custom_tool_schema_registry_exports, {
-  customToolSchemaRegistry: () => customToolSchemaRegistry,
-  getCustomToolSchemaRegistry: () => getCustomToolSchemaRegistry
-});
-module.exports = __toCommonJS(custom_tool_schema_registry_exports);
-var import_zod = require("zod");
-var import_types = require("../logger/v2/types.js");
-const createNoOpLogger = () => {
-  const noOpLogger = {
-    debug: () => {
-    },
-    info: () => {
-    },
-    warn: () => {
-    },
-    error: () => {
-    },
-    silly: () => {
-    },
-    trackException: () => {
-    },
-    setLevel: () => {
-    },
-    getLevel: () => "info",
-    getLogFilePath: () => null,
-    destroy: () => Promise.resolve(),
-    createChild: () => noOpLogger
-  };
-  return noOpLogger;
-};
-class CustomToolSchemaRegistry {
-  schemas = /* @__PURE__ */ new Map();
-  logger;
-  constructor(logger) {
-    this.logger = logger;
-  }
-  /**
-   * Register a provider's config schema.
-   * Called automatically when a custom tool provider is registered.
-   *
-   * @param type Provider type (must match the 'type' field in config)
-   * @param schema Zod schema for the provider's configuration
-   *
-   * @throws Error if schema is already registered for this type
-   */
-  register(type, schema) {
-    if (this.schemas.has(type)) {
-      throw new Error(`Config schema already registered for provider type: ${type}`);
-    }
-    this.schemas.set(type, schema);
-    this.logger.debug(`Registered config schema for provider: ${type}`);
-  }
-  /**
-   * Get a provider's config schema.
-   *
-   * @param type Provider type
-   * @returns The registered schema, or undefined if not found
-   */
-  get(type) {
-    return this.schemas.get(type);
-  }
-  /**
-   * Check if a provider type has a registered schema.
-   *
-   * @param type Provider type
-   * @returns true if schema is registered
-   */
-  has(type) {
-    return this.schemas.has(type);
-  }
-  /**
-   * Get all registered provider types.
-   *
-   * @returns Array of provider type strings
-   */
-  getRegisteredTypes() {
-    return Array.from(this.schemas.keys());
-  }
-  /**
-   * Create a discriminated union schema for all registered providers.
-   * This enables early validation of provider-specific fields at config load time.
-   *
-   * The union is discriminated by the 'type' field, which provides better error
-   * messages when validation fails.
-   *
-   * @returns Discriminated union schema if providers are registered,
-   *          passthrough schema otherwise (for backward compatibility)
-   */
-  createUnionSchema() {
-    const types = this.getRegisteredTypes();
-    if (types.length === 0) {
-      this.logger.debug(
-        "No provider schemas registered - using passthrough schema for custom tools"
-      );
-      return import_zod.z.object({
-        type: import_zod.z.string().describe("Custom tool provider type")
-      }).passthrough().describe(
-        "Custom tool provider configuration (no schemas registered - validation deferred to runtime)"
-      );
-    }
-    const schemas = [];
-    for (const type of types) {
-      const schema = this.get(type);
-      if (schema) {
-        schemas.push(schema);
-      }
-    }
-    if (schemas.length === 0) {
-      this.logger.warn("No schemas found despite having registered types");
-      return import_zod.z.object({
-        type: import_zod.z.string()
-      }).passthrough();
-    }
-    if (schemas.length === 1) {
-      this.logger.debug(`Using single provider schema: ${types[0]}`);
-      return schemas[0];
-    }
-    this.logger.debug(
-      `Creating union schema for ${schemas.length} providers: ${types.join(", ")}`
-    );
-    return import_zod.z.union(schemas);
-  }
-  /**
-   * Clear all registered schemas.
-   * Primarily used for testing.
-   */
-  clear() {
-    this.schemas.clear();
-    this.logger.debug("Cleared all registered provider schemas");
-  }
-}
-let globalInstance;
-function getCustomToolSchemaRegistry(logger) {
-  if (!globalInstance) {
-    const registryLogger = logger ? logger.createChild(import_types.DextoLogComponent.TOOLS) : createNoOpLogger();
-    globalInstance = new CustomToolSchemaRegistry(registryLogger);
-  }
-  return globalInstance;
-}
-const customToolSchemaRegistry = getCustomToolSchemaRegistry();
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  customToolSchemaRegistry,
-  getCustomToolSchemaRegistry
-});

package/dist/tools/custom-tool-schema-registry.d.ts

@@ -1,86 +0,0 @@
-/**
- * Custom Tool Schema Registry
- *
- * Registry for custom tool provider configuration schemas.
- * Allows core to validate provider-specific fields at config load time
- * by building a discriminated union of all registered schemas.
- *
- * Architecture:
- * 1. Providers register their config schemas when they register with customToolRegistry
- * 2. Core uses this registry to build a discriminated union schema at runtime
- * 3. Agent config validation uses the union to validate provider-specific fields early
- *
- * Benefits:
- * - Early validation (at config load time, not runtime)
- * - Type safety (full Zod validation for all provider fields)
- * - IDE support (TypeScript knows all provider fields)
- * - Single source of truth (provider schema defines everything)
- */
-import { z } from 'zod';
-import type { IDextoLogger } from '../logger/v2/types.js';
-declare class CustomToolSchemaRegistry {
-    private schemas;
-    private logger;
-    constructor(logger: IDextoLogger);
-    /**
-     * Register a provider's config schema.
-     * Called automatically when a custom tool provider is registered.
-     *
-     * @param type Provider type (must match the 'type' field in config)
-     * @param schema Zod schema for the provider's configuration
-     *
-     * @throws Error if schema is already registered for this type
-     */
-    register<T extends z.ZodType<any>>(type: string, schema: T): void;
-    /**
-     * Get a provider's config schema.
-     *
-     * @param type Provider type
-     * @returns The registered schema, or undefined if not found
-     */
-    get(type: string): z.ZodType<any> | undefined;
-    /**
-     * Check if a provider type has a registered schema.
-     *
-     * @param type Provider type
-     * @returns true if schema is registered
-     */
-    has(type: string): boolean;
-    /**
-     * Get all registered provider types.
-     *
-     * @returns Array of provider type strings
-     */
-    getRegisteredTypes(): string[];
-    /**
-     * Create a discriminated union schema for all registered providers.
-     * This enables early validation of provider-specific fields at config load time.
-     *
-     * The union is discriminated by the 'type' field, which provides better error
-     * messages when validation fails.
-     *
-     * @returns Discriminated union schema if providers are registered,
-     *          passthrough schema otherwise (for backward compatibility)
-     */
-    createUnionSchema(): z.ZodType<any>;
-    /**
-     * Clear all registered schemas.
-     * Primarily used for testing.
-     */
-    clear(): void;
-}
-/**
- * Get the global custom tool schema registry instance.
- * Creates it on first access with the provided logger.
- *
- * @param logger Optional logger for the registry (only used on first access)
- * @returns The global registry instance
- */
-export declare function getCustomToolSchemaRegistry(logger?: IDextoLogger): CustomToolSchemaRegistry;
-/**
- * Global custom tool schema registry instance.
- * Use this for registering and retrieving provider config schemas.
- */
-export declare const customToolSchemaRegistry: CustomToolSchemaRegistry;
-export {};
-//# sourceMappingURL=custom-tool-schema-registry.d.ts.map

package/dist/tools/custom-tool-schema-registry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"custom-tool-schema-registry.d.ts","sourceRoot":"","sources":["../../src/tools/custom-tool-schema-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AA8B1D,cAAM,wBAAwB;IAC1B,OAAO,CAAC,OAAO,CAAqC;IACpD,OAAO,CAAC,MAAM,CAAe;gBAEjB,MAAM,EAAE,YAAY;IAIhC;;;;;;;;OAQG;IACH,QAAQ,CAAC,CAAC,SAAS,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,GAAG,IAAI;IAQjE;;;;;OAKG;IACH,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,SAAS;IAI7C;;;;;OAKG;IACH,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAI1B;;;;OAIG;IACH,kBAAkB,IAAI,MAAM,EAAE;IAI9B;;;;;;;;;OASG;IACH,iBAAiB,IAAI,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC;IAsDnC;;;OAGG;IACH,KAAK,IAAI,IAAI;CAIhB;AAMD;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CAAC,MAAM,CAAC,EAAE,YAAY,GAAG,wBAAwB,CAQ3F;AAED;;;GAGG;AACH,eAAO,MAAM,wBAAwB,0BAAgC,CAAC"}

package/dist/tools/custom-tool-schema-registry.js

@@ -1,140 +0,0 @@
-import "../chunk-PTJYTZNU.js";
-import { z } from "zod";
-import { DextoLogComponent } from "../logger/v2/types.js";
-const createNoOpLogger = () => {
-  const noOpLogger = {
-    debug: () => {
-    },
-    info: () => {
-    },
-    warn: () => {
-    },
-    error: () => {
-    },
-    silly: () => {
-    },
-    trackException: () => {
-    },
-    setLevel: () => {
-    },
-    getLevel: () => "info",
-    getLogFilePath: () => null,
-    destroy: () => Promise.resolve(),
-    createChild: () => noOpLogger
-  };
-  return noOpLogger;
-};
-class CustomToolSchemaRegistry {
-  schemas = /* @__PURE__ */ new Map();
-  logger;
-  constructor(logger) {
-    this.logger = logger;
-  }
-  /**
-   * Register a provider's config schema.
-   * Called automatically when a custom tool provider is registered.
-   *
-   * @param type Provider type (must match the 'type' field in config)
-   * @param schema Zod schema for the provider's configuration
-   *
-   * @throws Error if schema is already registered for this type
-   */
-  register(type, schema) {
-    if (this.schemas.has(type)) {
-      throw new Error(`Config schema already registered for provider type: ${type}`);
-    }
-    this.schemas.set(type, schema);
-    this.logger.debug(`Registered config schema for provider: ${type}`);
-  }
-  /**
-   * Get a provider's config schema.
-   *
-   * @param type Provider type
-   * @returns The registered schema, or undefined if not found
-   */
-  get(type) {
-    return this.schemas.get(type);
-  }
-  /**
-   * Check if a provider type has a registered schema.
-   *
-   * @param type Provider type
-   * @returns true if schema is registered
-   */
-  has(type) {
-    return this.schemas.has(type);
-  }
-  /**
-   * Get all registered provider types.
-   *
-   * @returns Array of provider type strings
-   */
-  getRegisteredTypes() {
-    return Array.from(this.schemas.keys());
-  }
-  /**
-   * Create a discriminated union schema for all registered providers.
-   * This enables early validation of provider-specific fields at config load time.
-   *
-   * The union is discriminated by the 'type' field, which provides better error
-   * messages when validation fails.
-   *
-   * @returns Discriminated union schema if providers are registered,
-   *          passthrough schema otherwise (for backward compatibility)
-   */
-  createUnionSchema() {
-    const types = this.getRegisteredTypes();
-    if (types.length === 0) {
-      this.logger.debug(
-        "No provider schemas registered - using passthrough schema for custom tools"
-      );
-      return z.object({
-        type: z.string().describe("Custom tool provider type")
-      }).passthrough().describe(
-        "Custom tool provider configuration (no schemas registered - validation deferred to runtime)"
-      );
-    }
-    const schemas = [];
-    for (const type of types) {
-      const schema = this.get(type);
-      if (schema) {
-        schemas.push(schema);
-      }
-    }
-    if (schemas.length === 0) {
-      this.logger.warn("No schemas found despite having registered types");
-      return z.object({
-        type: z.string()
-      }).passthrough();
-    }
-    if (schemas.length === 1) {
-      this.logger.debug(`Using single provider schema: ${types[0]}`);
-      return schemas[0];
-    }
-    this.logger.debug(
-      `Creating union schema for ${schemas.length} providers: ${types.join(", ")}`
-    );
-    return z.union(schemas);
-  }
-  /**
-   * Clear all registered schemas.
-   * Primarily used for testing.
-   */
-  clear() {
-    this.schemas.clear();
-    this.logger.debug("Cleared all registered provider schemas");
-  }
-}
-let globalInstance;
-function getCustomToolSchemaRegistry(logger) {
-  if (!globalInstance) {
-    const registryLogger = logger ? logger.createChild(DextoLogComponent.TOOLS) : createNoOpLogger();
-    globalInstance = new CustomToolSchemaRegistry(registryLogger);
-  }
-  return globalInstance;
-}
-const customToolSchemaRegistry = getCustomToolSchemaRegistry();
-export {
-  customToolSchemaRegistry,
-  getCustomToolSchemaRegistry
-};

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

@@ -1,12 +0,0 @@
-/**
- * Internal tool constants
- *
- * Separated from registry to avoid circular dependencies and browser bundle pollution
- */
-/**
- * Available internal tool names
- * Must be kept in sync with INTERNAL_TOOL_REGISTRY in registry.ts
- */
-export declare const INTERNAL_TOOL_NAMES: readonly ["search_history", "ask_user", "delegate_to_url", "list_resources", "get_resource", "invoke_skill"];
-export type KnownInternalTool = (typeof INTERNAL_TOOL_NAMES)[number];
-//# sourceMappingURL=constants.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/tools/internal-tools/constants.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH;;;GAGG;AACH,eAAO,MAAM,mBAAmB,8GAOtB,CAAC;AAEX,MAAM,MAAM,iBAAiB,GAAG,CAAC,OAAO,mBAAmB,CAAC,CAAC,MAAM,CAAC,CAAC"}

package/dist/tools/internal-tools/constants.js

@@ -1,12 +0,0 @@
-import "../../chunk-PTJYTZNU.js";
-const INTERNAL_TOOL_NAMES = [
-  "search_history",
-  "ask_user",
-  "delegate_to_url",
-  "list_resources",
-  "get_resource",
-  "invoke_skill"
-];
-export {
-  INTERNAL_TOOL_NAMES
-};

package/dist/tools/internal-tools/implementations/ask-user-tool.cjs

@@ -1,57 +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 ask_user_tool_exports = {};
-__export(ask_user_tool_exports, {
-  createAskUserTool: () => createAskUserTool
-});
-module.exports = __toCommonJS(ask_user_tool_exports);
-var import_zod = require("zod");
-const AskUserInputSchema = import_zod.z.object({
-  question: import_zod.z.string().describe("The question or prompt to display to the user"),
-  schema: import_zod.z.object({
-    type: import_zod.z.literal("object"),
-    properties: import_zod.z.record(import_zod.z.unknown()),
-    required: import_zod.z.array(import_zod.z.string()).optional()
-  }).passthrough().describe(
-    'JSON Schema defining form fields. Use descriptive property names as labels (e.g., "favorite_team", "World Cup winner country") - NOT generic names like "q1". Use "enum" for dropdowns, "boolean" for yes/no, "number" for numeric inputs, "string" for text. Include "required" array for mandatory fields.'
-  )
-}).strict();
-function createAskUserTool(approvalManager) {
-  return {
-    id: "ask_user",
-    description: 'Collect structured input from the user through a form interface. ONLY use this tool when you need: 1) Multiple fields at once (e.g., name + email + preferences), 2) Pre-defined options/choices (use enum for dropdowns like ["small","medium","large"]), 3) Specific data types with validation (boolean for yes/no, number for quantities). DO NOT use for simple conversational questions - just ask those naturally in your response. This tool is for form-like data collection, not chat. Examples: collecting user profile info, configuration settings, or selecting from preset options.',
-    inputSchema: AskUserInputSchema,
-    execute: async (input, context) => {
-      const { question, schema } = input;
-      const elicitationRequest = {
-        schema,
-        prompt: question,
-        serverName: "Dexto Agent"
-      };
-      if (context?.sessionId !== void 0) {
-        elicitationRequest.sessionId = context.sessionId;
-      }
-      return approvalManager.getElicitationData(elicitationRequest);
-    }
-  };
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  createAskUserTool
-});

package/dist/tools/internal-tools/implementations/ask-user-tool.d.ts

@@ -1,18 +0,0 @@
-import { InternalTool } from '../../types.js';
-import { ApprovalManager } from '../../../approval/manager.js';
-/**
- * Internal tool for asking the user questions during agent execution
- * Leverages the ApprovalManager to prompt the user cross-platform (CLI, WebUI)
- *
- * Usage distinction:
- * - ask_user tool: Agent-initiated form-based input requests during task execution
- *   (e.g., agent decides it needs specific information to complete a task)
- * - MCP elicitation: Server-initiated input requests from external MCP servers
- *   (e.g., MCP server requires configuration or authentication data)
- *
- * Both use ApprovalManager.requestElicitation() under the hood but serve different purposes:
- * - ask_user: Part of agent's internal reasoning and task workflow
- * - MCP elicitation: External server requirements for tool/resource access
- */
-export declare function createAskUserTool(approvalManager: ApprovalManager): InternalTool;
-//# sourceMappingURL=ask-user-tool.d.ts.map

package/dist/tools/internal-tools/implementations/ask-user-tool.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ask-user-tool.d.ts","sourceRoot":"","sources":["../../../../src/tools/internal-tools/implementations/ask-user-tool.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAwB,MAAM,gBAAgB,CAAC;AACpE,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAoB/D;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iBAAiB,CAAC,eAAe,EAAE,eAAe,GAAG,YAAY,CA+BhF"}