@dexto/core 1.5.8 → 1.6.1

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

@@ -1,301 +0,0 @@
-import "../../chunk-PTJYTZNU.js";
-import { ToolError } from "../errors.js";
-import { convertZodSchemaToJsonSchema } from "../../utils/schema.js";
-import { getInternalToolInfo } from "./registry.js";
-import { customToolRegistry } from "../custom-tool-registry.js";
-import { DextoRuntimeError } from "../../errors/DextoRuntimeError.js";
-import { ToolErrorCode } from "../error-codes.js";
-class InternalToolsProvider {
-  services;
-  internalTools = /* @__PURE__ */ new Map();
-  // Built-in internal tools
-  customTools = /* @__PURE__ */ new Map();
-  // Custom tool provider tools
-  config;
-  customToolConfigs;
-  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,
-      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;
-  }
-  /**
-   * Set prompt manager after construction (avoids circular dependency)
-   * Must be called before initialize() if invoke_skill tool is enabled
-   */
-  setPromptManager(promptManager) {
-    this.services.promptManager = promptManager;
-  }
-  /**
-   * Set task forker for context:fork skill execution (late-binding)
-   * Called by agent-spawner custom tool provider after RuntimeService is created.
-   * This enables invoke_skill to fork execution to an isolated subagent.
-   */
-  setTaskForker(taskForker) {
-    this.services.taskForker = taskForker;
-  }
-  /**
-   * 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) {
-        this.registerInternalTools();
-      } else {
-        this.logger.info("No internal tools enabled by configuration");
-      }
-      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)}`
-      );
-      throw error;
-    }
-  }
-  /**
-   * Register all available internal tools based on available services and configuration
-   */
-  registerInternalTools() {
-    const featureFlags = {
-      elicitation: this.services.approvalManager?.getConfig().elicitation.enabled ?? false
-    };
-    for (const toolName of this.config) {
-      const toolInfo = getInternalToolInfo(toolName);
-      const missingServices = toolInfo.requiredServices.filter(
-        (serviceKey) => !this.services[serviceKey]
-      );
-      if (missingServices.length > 0) {
-        this.logger.debug(
-          `Skipping ${toolName} internal tool - missing services: ${missingServices.join(", ")}`
-        );
-        continue;
-      }
-      const missingFeatures = (toolInfo.requiredFeatures ?? []).filter(
-        (feature) => !featureFlags[feature]
-      );
-      if (missingFeatures.length > 0) {
-        throw ToolError.featureDisabled(
-          toolName,
-          missingFeatures,
-          `Tool '${toolName}' requires features which are currently disabled: ${missingFeatures.join(", ")}. Either remove '${toolName}' from internalTools, or enable: ${missingFeatures.map((f) => `${f}.enabled: true`).join(", ")}`
-        );
-      }
-      try {
-        const tool = toolInfo.factory(this.services);
-        this.internalTools.set(toolName, tool);
-        this.logger.debug(`Registered ${toolName} internal tool`);
-      } catch (error) {
-        this.logger.error(
-          `Failed to register ${toolName} internal tool: ${error instanceof Error ? error.message : String(error)}`
-        );
-      }
-    }
-  }
-  /**
-   * 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 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 = customToolRegistry.validateConfig(toolConfig);
-        const provider = customToolRegistry.get(validatedConfig.type);
-        if (!provider) {
-          const availableTypes = customToolRegistry.getTypes();
-          throw 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 DextoRuntimeError && error.code === 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.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.internalTools.get(toolName) || this.customTools.get(toolName);
-  }
-  /**
-   * Execute an internal tool - confirmation is handled by ToolManager
-   */
-  async executeTool(toolName, args, sessionId, abortSignal, toolCallId) {
-    const tool = this.internalTools.get(toolName) || this.customTools.get(toolName);
-    if (!tool) {
-      this.logger.error(`\u274C No tool found: ${toolName}`);
-      this.logger.debug(
-        `Available internal tools: ${Array.from(this.internalTools.keys()).join(", ")}`
-      );
-      this.logger.debug(
-        `Available custom tools: ${Array.from(this.customTools.keys()).join(", ")}`
-      );
-      throw ToolError.notFound(toolName);
-    }
-    const validationResult = tool.inputSchema.safeParse(args);
-    if (!validationResult.success) {
-      this.logger.error(
-        `\u274C Invalid arguments for tool ${toolName}: ${validationResult.error.message}`
-      );
-      throw ToolError.invalidName(
-        toolName,
-        `Invalid arguments: ${validationResult.error.message}`
-      );
-    }
-    try {
-      const context = {
-        sessionId,
-        abortSignal,
-        toolCallId
-      };
-      const result = await tool.execute(validationResult.data, context);
-      return result;
-    } catch (error) {
-      this.logger.error(`\u274C Internal tool execution failed: ${toolName}`, {
-        error: error instanceof Error ? error.message : String(error)
-      });
-      throw error;
-    }
-  }
-  /**
-   * 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: convertZodSchemaToJsonSchema(tool.inputSchema, this.logger)
-      };
-    }
-    return toolSet;
-  }
-  /**
-   * Get custom tools in ToolSet format (excludes internal tools)
-   */
-  getCustomTools() {
-    const toolSet = {};
-    for (const [name, tool] of this.customTools) {
-      toolSet[name] = {
-        name: tool.id,
-        description: tool.description,
-        parameters: convertZodSchemaToJsonSchema(tool.inputSchema, this.logger)
-      };
-    }
-    return toolSet;
-  }
-  /**
-   * 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 [...this.internalTools.keys(), ...this.customTools.keys()];
-  }
-  /**
-   * Get tool count
-   */
-  getToolCount() {
-    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;
-  }
-}
-export {
-  InternalToolsProvider
-};

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

@@ -1,71 +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 registry_exports = {};
-__export(registry_exports, {
-  INTERNAL_TOOL_REGISTRY: () => INTERNAL_TOOL_REGISTRY,
-  getInternalToolInfo: () => getInternalToolInfo
-});
-module.exports = __toCommonJS(registry_exports);
-var import_search_history_tool = require("./implementations/search-history-tool.js");
-var import_ask_user_tool = require("./implementations/ask-user-tool.js");
-var import_delegate_to_url_tool = require("./implementations/delegate-to-url-tool.js");
-var import_list_resources_tool = require("./implementations/list-resources-tool.js");
-var import_get_resource_tool = require("./implementations/get-resource-tool.js");
-var import_invoke_skill_tool = require("./implementations/invoke-skill-tool.js");
-const INTERNAL_TOOL_REGISTRY = {
-  search_history: {
-    factory: (services) => (0, import_search_history_tool.createSearchHistoryTool)(services.searchService),
-    requiredServices: ["searchService"],
-    description: "Search through conversation history across sessions"
-  },
-  ask_user: {
-    factory: (services) => (0, import_ask_user_tool.createAskUserTool)(services.approvalManager),
-    requiredServices: ["approvalManager"],
-    requiredFeatures: ["elicitation"],
-    description: "Collect structured input from the user through a form interface"
-  },
-  delegate_to_url: {
-    factory: (_services) => (0, import_delegate_to_url_tool.createDelegateToUrlTool)(),
-    requiredServices: [],
-    description: "Delegate tasks to another A2A-compliant agent via URL"
-  },
-  list_resources: {
-    factory: (services) => (0, import_list_resources_tool.createListResourcesTool)(services.resourceManager),
-    requiredServices: ["resourceManager"],
-    description: "List available resources (images, files, etc.)"
-  },
-  get_resource: {
-    factory: (services) => (0, import_get_resource_tool.createGetResourceTool)(services.resourceManager),
-    requiredServices: ["resourceManager"],
-    description: "Access a stored resource to get URLs or metadata"
-  },
-  invoke_skill: {
-    factory: (services) => (0, import_invoke_skill_tool.createInvokeSkillTool)(services),
-    requiredServices: ["promptManager"],
-    description: "Invoke a skill to load specialized instructions for a task"
-  }
-};
-function getInternalToolInfo(toolName) {
-  return INTERNAL_TOOL_REGISTRY[toolName];
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  INTERNAL_TOOL_REGISTRY,
-  getInternalToolInfo
-});

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

@@ -1,91 +0,0 @@
-import { InternalTool } from '../types.js';
-import { SearchService } from '../../search/index.js';
-import { ApprovalManager } from '../../approval/manager.js';
-import { ResourceManager } from '../../resources/manager.js';
-import type { PromptManager } from '../../prompts/prompt-manager.js';
-import type { KnownInternalTool } from './constants.js';
-/**
- * Agent features that tools can depend on.
- * Tools can declare required features via `requiredFeatures` in the registry.
- * If a required feature is disabled, the tool will not be registered and agent startup will fail.
- *
- * To add new features:
- * 1. Add the feature name to this union type (e.g., 'elicitation' | 'file_access' | 'network_access')
- * 2. Add the feature flag derivation in provider.ts `registerInternalTools()`:
- *    ```
- *    const featureFlags: Record<AgentFeature, boolean> = {
- *        elicitation: this.services.approvalManager?.getConfig().elicitation.enabled ?? false,
- *        file_access: config.fileAccess?.enabled ?? false,  // example
- *    };
- *    ```
- * 3. Add `requiredFeatures: ['feature_name'] as const` to tool entries that need it
- *
- * Tools can require multiple features - all must be enabled or startup fails with a clear error.
- */
-export type AgentFeature = 'elicitation';
-/**
- * Interface for forking skill execution to an isolated subagent.
- * Implemented by RuntimeService in @dexto/agent-management.
- */
-export interface TaskForker {
-    /**
-     * Execute a task in an isolated subagent context.
-     * The subagent has no access to the parent's conversation history.
-     *
-     * @param options.task - Short description for UI/logs
-     * @param options.instructions - Full instructions for the subagent
-     * @param options.agentId - Optional agent ID from registry to use for execution
-     * @param options.autoApprove - Auto-approve tool calls (default: true for fork skills)
-     * @param options.toolCallId - Optional tool call ID for progress events
-     * @param options.sessionId - Optional session ID for progress events
-     * @returns Result with success status and response/error
-     */
-    fork(options: {
-        task: string;
-        instructions: string;
-        agentId?: string;
-        autoApprove?: boolean;
-        toolCallId?: string;
-        sessionId?: string;
-    }): Promise<{
-        success: boolean;
-        response?: string;
-        error?: string;
-    }>;
-}
-/**
- * Services available to internal tools
- * Add new services here as needed for internal tools
- */
-export interface InternalToolsServices extends Record<string, unknown> {
-    searchService?: SearchService;
-    approvalManager?: ApprovalManager;
-    resourceManager?: ResourceManager;
-    promptManager?: PromptManager;
-    /** Optional forker for executing skills in isolated context (context: fork) */
-    taskForker?: TaskForker;
-}
-/**
- * Internal tool factory function type
- */
-type InternalToolFactory = (services: InternalToolsServices) => InternalTool;
-/**
- * Internal tool registry entry type
- */
-export interface InternalToolRegistryEntry {
-    factory: InternalToolFactory;
-    requiredServices: readonly (keyof InternalToolsServices)[];
-    requiredFeatures?: readonly AgentFeature[];
-    /** Short description for discovery/UI purposes */
-    description: string;
-}
-/**
- * Internal tool registry - Must match names array exactly (TypeScript enforces this)
- */
-export declare const INTERNAL_TOOL_REGISTRY: Record<KnownInternalTool, InternalToolRegistryEntry>;
-/**
- * Type-safe registry access
- */
-export declare function getInternalToolInfo(toolName: KnownInternalTool): InternalToolRegistryEntry;
-export {};
-//# sourceMappingURL=registry.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../src/tools/internal-tools/registry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACtD,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAC5D,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAC7D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AAOrE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAExD;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,MAAM,YAAY,GAAG,aAAa,CAAC;AAEzC;;;GAGG;AACH,MAAM,WAAW,UAAU;IACvB;;;;;;;;;;;OAWG;IACH,IAAI,CAAC,OAAO,EAAE;QACV,IAAI,EAAE,MAAM,CAAC;QACb,YAAY,EAAE,MAAM,CAAC;QACrB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,WAAW,CAAC,EAAE,OAAO,CAAC;QACtB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,SAAS,CAAC,EAAE,MAAM,CAAC;KACtB,GAAG,OAAO,CAAC;QACR,OAAO,EAAE,OAAO,CAAC;QACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,KAAK,CAAC,EAAE,MAAM,CAAC;KAClB,CAAC,CAAC;CACN;AAED;;;GAGG;AACH,MAAM,WAAW,qBAAsB,SAAQ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAClE,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B,+EAA+E;IAC/E,UAAU,CAAC,EAAE,UAAU,CAAC;CAC3B;AAED;;GAEG;AACH,KAAK,mBAAmB,GAAG,CAAC,QAAQ,EAAE,qBAAqB,KAAK,YAAY,CAAC;AAE7E;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACtC,OAAO,EAAE,mBAAmB,CAAC;IAC7B,gBAAgB,EAAE,SAAS,CAAC,MAAM,qBAAqB,CAAC,EAAE,CAAC;IAC3D,gBAAgB,CAAC,EAAE,SAAS,YAAY,EAAE,CAAC;IAC3C,kDAAkD;IAClD,WAAW,EAAE,MAAM,CAAC;CACvB;AAED;;GAEG;AACH,eAAO,MAAM,sBAAsB,EAAE,MAAM,CAAC,iBAAiB,EAAE,yBAAyB,CAmCvF,CAAC;AAEF;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,iBAAiB,GAAG,yBAAyB,CAE1F"}

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

@@ -1,47 +0,0 @@
-import "../../chunk-PTJYTZNU.js";
-import { createSearchHistoryTool } from "./implementations/search-history-tool.js";
-import { createAskUserTool } from "./implementations/ask-user-tool.js";
-import { createDelegateToUrlTool } from "./implementations/delegate-to-url-tool.js";
-import { createListResourcesTool } from "./implementations/list-resources-tool.js";
-import { createGetResourceTool } from "./implementations/get-resource-tool.js";
-import { createInvokeSkillTool } from "./implementations/invoke-skill-tool.js";
-const INTERNAL_TOOL_REGISTRY = {
-  search_history: {
-    factory: (services) => createSearchHistoryTool(services.searchService),
-    requiredServices: ["searchService"],
-    description: "Search through conversation history across sessions"
-  },
-  ask_user: {
-    factory: (services) => createAskUserTool(services.approvalManager),
-    requiredServices: ["approvalManager"],
-    requiredFeatures: ["elicitation"],
-    description: "Collect structured input from the user through a form interface"
-  },
-  delegate_to_url: {
-    factory: (_services) => createDelegateToUrlTool(),
-    requiredServices: [],
-    description: "Delegate tasks to another A2A-compliant agent via URL"
-  },
-  list_resources: {
-    factory: (services) => createListResourcesTool(services.resourceManager),
-    requiredServices: ["resourceManager"],
-    description: "List available resources (images, files, etc.)"
-  },
-  get_resource: {
-    factory: (services) => createGetResourceTool(services.resourceManager),
-    requiredServices: ["resourceManager"],
-    description: "Access a stored resource to get URLs or metadata"
-  },
-  invoke_skill: {
-    factory: (services) => createInvokeSkillTool(services),
-    requiredServices: ["promptManager"],
-    description: "Invoke a skill to load specialized instructions for a task"
-  }
-};
-function getInternalToolInfo(toolName) {
-  return INTERNAL_TOOL_REGISTRY[toolName];
-}
-export {
-  INTERNAL_TOOL_REGISTRY,
-  getInternalToolInfo
-};