@dexto/core 1.1.4 → 1.1.6

package/dist/tools/internal-tools/implementations/search-history-tool.js

@@ -0,0 +1,37 @@
+import { z } from "zod";
+const SearchHistoryInputSchema = z.object({
+  query: z.string().describe("The search query to find in conversation history"),
+  mode: z.enum(["messages", "sessions"]).describe(
+    'Search mode: "messages" searches for individual messages, "sessions" finds sessions containing the query'
+  ),
+  sessionId: z.string().optional().describe('Optional: limit search to a specific session (only for mode="messages")'),
+  role: z.enum(["user", "assistant", "system", "tool"]).optional().describe('Optional: filter by message role (only for mode="messages")'),
+  limit: z.number().optional().default(20).describe(
+    'Optional: maximum number of results to return (default: 20, only for mode="messages")'
+  ),
+  offset: z.number().optional().default(0).describe('Optional: offset for pagination (default: 0, only for mode="messages")')
+});
+function createSearchHistoryTool(searchService) {
+  return {
+    id: "search_history",
+    description: 'Search through conversation history across sessions. Use mode="messages" to search for specific messages, or mode="sessions" to find sessions containing the query. For message search, you can filter by sessionId (specific session), role (user/assistant/system/tool), limit results, and set pagination offset.',
+    inputSchema: SearchHistoryInputSchema,
+    // TODO: Enhance to get SearchService via ToolExecutionContext for better separation of concerns
+    execute: async (input, _context) => {
+      const { query, mode, sessionId, role, limit, offset } = input;
+      if (mode === "messages") {
+        const searchOptions = {};
+        if (sessionId !== void 0) searchOptions.sessionId = sessionId;
+        if (role !== void 0) searchOptions.role = role;
+        if (limit !== void 0) searchOptions.limit = limit;
+        if (offset !== void 0) searchOptions.offset = offset;
+        return await searchService.searchMessages(query, searchOptions);
+      } else {
+        return await searchService.searchSessions(query);
+      }
+    }
+  };
+}
+export {
+  createSearchHistoryTool
+};

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

@@ -0,0 +1,24 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var internal_tools_exports = {};
+module.exports = __toCommonJS(internal_tools_exports);
+__reExport(internal_tools_exports, require("./provider.js"), module.exports);
+__reExport(internal_tools_exports, require("./registry.js"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./provider.js"),
+  ...require("./registry.js")
+});

package/dist/tools/internal-tools/index.d.cts

@@ -0,0 +1,13 @@
+export { InternalToolsProvider } from './provider.cjs';
+export { INTERNAL_TOOL_NAMES, INTERNAL_TOOL_REGISTRY, InternalToolsServices, KnownInternalTool, getInternalToolInfo } from './registry.cjs';
+import '../types.cjs';
+import 'json-schema';
+import 'zod';
+import '../confirmation/types.cjs';
+import '../confirmation/allowed-tools-provider/types.cjs';
+import '../schemas.cjs';
+import '../../search/search-service.cjs';
+import '../../storage/backend/database-backend.cjs';
+import '../../search/types.cjs';
+import '../../context/types.cjs';
+import '../../llm/types.cjs';

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

@@ -0,0 +1,13 @@
+export { InternalToolsProvider } from './provider.js';
+export { INTERNAL_TOOL_NAMES, INTERNAL_TOOL_REGISTRY, InternalToolsServices, KnownInternalTool, getInternalToolInfo } from './registry.js';
+import '../types.js';
+import 'json-schema';
+import 'zod';
+import '../confirmation/types.js';
+import '../confirmation/allowed-tools-provider/types.js';
+import '../schemas.js';
+import '../../search/search-service.js';
+import '../../storage/backend/database-backend.js';
+import '../../search/types.js';
+import '../../context/types.js';
+import '../../llm/types.js';

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

@@ -0,0 +1,2 @@
+export * from "./provider.js";
+export * from "./registry.js";

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

@@ -0,0 +1,159 @@
+"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 provider_exports = {};
+__export(provider_exports, {
+  InternalToolsProvider: () => InternalToolsProvider
+});
+module.exports = __toCommonJS(provider_exports);
+var import_logger = require("../../logger/index.js");
+var import_errors = require("../errors.js");
+var import_schema = require("../../utils/schema.js");
+var import_registry = require("./registry.js");
+class InternalToolsProvider {
+  services;
+  tools = /* @__PURE__ */ new Map();
+  // ← Store original InternalTool
+  confirmationProvider;
+  config;
+  constructor(services, confirmationProvider, config = []) {
+    this.services = services;
+    this.confirmationProvider = confirmationProvider;
+    this.config = config;
+    import_logger.logger.debug("InternalToolsProvider initialized with config:", config);
+  }
+  /**
+   * Initialize the internal tools provider by registering all available internal tools
+   */
+  async initialize() {
+    import_logger.logger.info("Initializing InternalToolsProvider...");
+    try {
+      if (this.config.length === 0) {
+        import_logger.logger.info("No internal tools enabled by configuration");
+        return;
+      }
+      this.registerInternalTools();
+      const toolCount = this.tools.size;
+      import_logger.logger.info(`InternalToolsProvider initialized with ${toolCount} internal tools`);
+    } catch (error) {
+      import_logger.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() {
+    for (const toolName of this.config) {
+      const toolInfo = (0, import_registry.getInternalToolInfo)(toolName);
+      const missingServices = toolInfo.requiredServices.filter(
+        (serviceKey) => !this.services[serviceKey]
+      );
+      if (missingServices.length > 0) {
+        import_logger.logger.debug(
+          `Skipping ${toolName} internal tool - missing services: ${missingServices.join(", ")}`
+        );
+        continue;
+      }
+      try {
+        const tool = toolInfo.factory(this.services);
+        this.tools.set(toolName, tool);
+        import_logger.logger.debug(`Registered ${toolName} internal tool`);
+      } catch (error) {
+        import_logger.logger.error(
+          `Failed to register ${toolName} internal tool: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  }
+  /**
+   * Check if a specific tool is enabled by configuration
+   */
+  isToolEnabled(toolName) {
+    return this.config.includes(toolName);
+  }
+  /**
+   * Check if a tool exists
+   */
+  hasTool(toolName) {
+    return this.tools.has(toolName);
+  }
+  /**
+   * Execute an internal tool - confirmation is handled by ToolManager
+   */
+  async executeTool(toolName, args, sessionId) {
+    const tool = this.tools.get(toolName);
+    if (!tool) {
+      import_logger.logger.error(`\u274C No internal tool found: ${toolName}`);
+      import_logger.logger.debug(`Available internal tools: ${Array.from(this.tools.keys()).join(", ")}`);
+      throw import_errors.ToolError.notFound(toolName);
+    }
+    const validationResult = tool.inputSchema.safeParse(args);
+    if (!validationResult.success) {
+      import_logger.logger.error(
+        `\u274C Invalid arguments for tool ${toolName}:`,
+        validationResult.error.message
+      );
+      throw import_errors.ToolError.invalidName(
+        toolName,
+        `Invalid arguments: ${validationResult.error.message}`
+      );
+    }
+    try {
+      const context = { sessionId };
+      const result = await tool.execute(validationResult.data, context);
+      return result;
+    } catch (error) {
+      import_logger.logger.error(`\u274C Internal tool execution failed: ${toolName}`, error);
+      throw error;
+    }
+  }
+  /**
+   * Get all tools in ToolSet format with on-demand JSON Schema conversion
+   */
+  getAllTools() {
+    const toolSet = {};
+    for (const [name, tool] of this.tools) {
+      toolSet[name] = {
+        name: tool.id,
+        description: tool.description,
+        parameters: (0, import_schema.convertZodSchemaToJsonSchema)(tool.inputSchema)
+        // ← Convert on-demand
+      };
+    }
+    return toolSet;
+  }
+  /**
+   * Get tool names
+   */
+  getToolNames() {
+    return Array.from(this.tools.keys());
+  }
+  /**
+   * Get tool count
+   */
+  getToolCount() {
+    return this.tools.size;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InternalToolsProvider
+});

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

@@ -0,0 +1,66 @@
+import { ToolSet } from '../types.cjs';
+import { ToolConfirmationProvider } from '../confirmation/types.cjs';
+import { InternalToolsServices } from './registry.cjs';
+import { InternalToolsConfig } from '../schemas.cjs';
+import 'json-schema';
+import 'zod';
+import '../confirmation/allowed-tools-provider/types.cjs';
+import '../../search/search-service.cjs';
+import '../../storage/backend/database-backend.cjs';
+import '../../search/types.cjs';
+import '../../context/types.cjs';
+import '../../llm/types.cjs';
+
+/**
+ * Provider for built-in internal tools that are part of the core system
+ *
+ * This provider manages internal tools that are shipped with the core system
+ * and need access to core services like SearchService, SessionManager, etc.
+ *
+ * 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
+ */
+declare class InternalToolsProvider {
+    private services;
+    private tools;
+    private confirmationProvider;
+    private config;
+    constructor(services: InternalToolsServices, confirmationProvider: ToolConfirmationProvider, config?: InternalToolsConfig);
+    /**
+     * Initialize the internal tools provider by registering all available internal tools
+     */
+    initialize(): Promise<void>;
+    /**
+     * Register all available internal tools based on available services and configuration
+     */
+    private registerInternalTools;
+    /**
+     * Check if a specific tool is enabled by configuration
+     */
+    private isToolEnabled;
+    /**
+     * Check if a tool exists
+     */
+    hasTool(toolName: string): boolean;
+    /**
+     * Execute an internal tool - confirmation is handled by ToolManager
+     */
+    executeTool(toolName: string, args: Record<string, unknown>, sessionId?: string): Promise<unknown>;
+    /**
+     * Get all tools in ToolSet format with on-demand JSON Schema conversion
+     */
+    getAllTools(): ToolSet;
+    /**
+     * Get tool names
+     */
+    getToolNames(): string[];
+    /**
+     * Get tool count
+     */
+    getToolCount(): number;
+}
+
+export { InternalToolsProvider };

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

@@ -0,0 +1,66 @@
+import { ToolSet } from '../types.js';
+import { ToolConfirmationProvider } from '../confirmation/types.js';
+import { InternalToolsServices } from './registry.js';
+import { InternalToolsConfig } from '../schemas.js';
+import 'json-schema';
+import 'zod';
+import '../confirmation/allowed-tools-provider/types.js';
+import '../../search/search-service.js';
+import '../../storage/backend/database-backend.js';
+import '../../search/types.js';
+import '../../context/types.js';
+import '../../llm/types.js';
+
+/**
+ * Provider for built-in internal tools that are part of the core system
+ *
+ * This provider manages internal tools that are shipped with the core system
+ * and need access to core services like SearchService, SessionManager, etc.
+ *
+ * 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
+ */
+declare class InternalToolsProvider {
+    private services;
+    private tools;
+    private confirmationProvider;
+    private config;
+    constructor(services: InternalToolsServices, confirmationProvider: ToolConfirmationProvider, config?: InternalToolsConfig);
+    /**
+     * Initialize the internal tools provider by registering all available internal tools
+     */
+    initialize(): Promise<void>;
+    /**
+     * Register all available internal tools based on available services and configuration
+     */
+    private registerInternalTools;
+    /**
+     * Check if a specific tool is enabled by configuration
+     */
+    private isToolEnabled;
+    /**
+     * Check if a tool exists
+     */
+    hasTool(toolName: string): boolean;
+    /**
+     * Execute an internal tool - confirmation is handled by ToolManager
+     */
+    executeTool(toolName: string, args: Record<string, unknown>, sessionId?: string): Promise<unknown>;
+    /**
+     * Get all tools in ToolSet format with on-demand JSON Schema conversion
+     */
+    getAllTools(): ToolSet;
+    /**
+     * Get tool names
+     */
+    getToolNames(): string[];
+    /**
+     * Get tool count
+     */
+    getToolCount(): number;
+}
+
+export { InternalToolsProvider };

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

@@ -0,0 +1,135 @@
+import { logger } from "../../logger/index.js";
+import { ToolError } from "../errors.js";
+import { convertZodSchemaToJsonSchema } from "../../utils/schema.js";
+import { getInternalToolInfo } from "./registry.js";
+class InternalToolsProvider {
+  services;
+  tools = /* @__PURE__ */ new Map();
+  // ← Store original InternalTool
+  confirmationProvider;
+  config;
+  constructor(services, confirmationProvider, config = []) {
+    this.services = services;
+    this.confirmationProvider = confirmationProvider;
+    this.config = config;
+    logger.debug("InternalToolsProvider initialized with config:", config);
+  }
+  /**
+   * Initialize the internal tools provider by registering all available internal tools
+   */
+  async initialize() {
+    logger.info("Initializing InternalToolsProvider...");
+    try {
+      if (this.config.length === 0) {
+        logger.info("No internal tools enabled by configuration");
+        return;
+      }
+      this.registerInternalTools();
+      const toolCount = this.tools.size;
+      logger.info(`InternalToolsProvider initialized with ${toolCount} internal tools`);
+    } catch (error) {
+      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() {
+    for (const toolName of this.config) {
+      const toolInfo = getInternalToolInfo(toolName);
+      const missingServices = toolInfo.requiredServices.filter(
+        (serviceKey) => !this.services[serviceKey]
+      );
+      if (missingServices.length > 0) {
+        logger.debug(
+          `Skipping ${toolName} internal tool - missing services: ${missingServices.join(", ")}`
+        );
+        continue;
+      }
+      try {
+        const tool = toolInfo.factory(this.services);
+        this.tools.set(toolName, tool);
+        logger.debug(`Registered ${toolName} internal tool`);
+      } catch (error) {
+        logger.error(
+          `Failed to register ${toolName} internal tool: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  }
+  /**
+   * Check if a specific tool is enabled by configuration
+   */
+  isToolEnabled(toolName) {
+    return this.config.includes(toolName);
+  }
+  /**
+   * Check if a tool exists
+   */
+  hasTool(toolName) {
+    return this.tools.has(toolName);
+  }
+  /**
+   * Execute an internal tool - confirmation is handled by ToolManager
+   */
+  async executeTool(toolName, args, sessionId) {
+    const tool = this.tools.get(toolName);
+    if (!tool) {
+      logger.error(`\u274C No internal tool found: ${toolName}`);
+      logger.debug(`Available internal tools: ${Array.from(this.tools.keys()).join(", ")}`);
+      throw ToolError.notFound(toolName);
+    }
+    const validationResult = tool.inputSchema.safeParse(args);
+    if (!validationResult.success) {
+      logger.error(
+        `\u274C Invalid arguments for tool ${toolName}:`,
+        validationResult.error.message
+      );
+      throw ToolError.invalidName(
+        toolName,
+        `Invalid arguments: ${validationResult.error.message}`
+      );
+    }
+    try {
+      const context = { sessionId };
+      const result = await tool.execute(validationResult.data, context);
+      return result;
+    } catch (error) {
+      logger.error(`\u274C Internal tool execution failed: ${toolName}`, error);
+      throw error;
+    }
+  }
+  /**
+   * Get all tools in ToolSet format with on-demand JSON Schema conversion
+   */
+  getAllTools() {
+    const toolSet = {};
+    for (const [name, tool] of this.tools) {
+      toolSet[name] = {
+        name: tool.id,
+        description: tool.description,
+        parameters: convertZodSchemaToJsonSchema(tool.inputSchema)
+        // ← Convert on-demand
+      };
+    }
+    return toolSet;
+  }
+  /**
+   * Get tool names
+   */
+  getToolNames() {
+    return Array.from(this.tools.keys());
+  }
+  /**
+   * Get tool count
+   */
+  getToolCount() {
+    return this.tools.size;
+  }
+}
+export {
+  InternalToolsProvider
+};

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

@@ -0,0 +1,43 @@
+"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_NAMES: () => INTERNAL_TOOL_NAMES,
+  INTERNAL_TOOL_REGISTRY: () => INTERNAL_TOOL_REGISTRY,
+  getInternalToolInfo: () => getInternalToolInfo
+});
+module.exports = __toCommonJS(registry_exports);
+var import_search_history_tool = require("./implementations/search-history-tool.js");
+const INTERNAL_TOOL_NAMES = ["search_history"];
+const INTERNAL_TOOL_REGISTRY = {
+  search_history: {
+    factory: (services) => (0, import_search_history_tool.createSearchHistoryTool)(services.searchService),
+    requiredServices: ["searchService"]
+  }
+  // Add new tools here - must match INTERNAL_TOOL_NAMES array above
+};
+function getInternalToolInfo(toolName) {
+  return INTERNAL_TOOL_REGISTRY[toolName];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  INTERNAL_TOOL_NAMES,
+  INTERNAL_TOOL_REGISTRY,
+  getInternalToolInfo
+});

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

@@ -0,0 +1,45 @@
+import { InternalTool } from '../types.cjs';
+import { SearchService } from '../../search/search-service.cjs';
+import 'json-schema';
+import 'zod';
+import '../../storage/backend/database-backend.cjs';
+import '../../search/types.cjs';
+import '../../context/types.cjs';
+import '../../llm/types.cjs';
+
+/**
+ * Services available to internal tools
+ * Add new services here as needed for internal tools
+ */
+interface InternalToolsServices {
+    searchService?: SearchService;
+}
+/**
+ * Internal tool factory function type
+ */
+type InternalToolFactory = (services: InternalToolsServices) => InternalTool;
+/**
+ * Internal tool names - Manual array preserves literal types for z.enum()
+ * Add new tool names here first, then implement in registry below
+ */
+declare const INTERNAL_TOOL_NAMES: readonly ["search_history"];
+/**
+ * Derive type from names array - preserves literal union
+ */
+type KnownInternalTool = (typeof INTERNAL_TOOL_NAMES)[number];
+/**
+ * Internal tool registry - Must match names array exactly (TypeScript enforces this)
+ */
+declare const INTERNAL_TOOL_REGISTRY: Record<KnownInternalTool, {
+    factory: InternalToolFactory;
+    requiredServices: readonly (keyof InternalToolsServices)[];
+}>;
+/**
+ * Type-safe registry access
+ */
+declare function getInternalToolInfo(toolName: KnownInternalTool): {
+    factory: InternalToolFactory;
+    requiredServices: readonly (keyof InternalToolsServices)[];
+};
+
+export { INTERNAL_TOOL_NAMES, INTERNAL_TOOL_REGISTRY, type InternalToolsServices, type KnownInternalTool, getInternalToolInfo };

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

@@ -0,0 +1,45 @@
+import { InternalTool } from '../types.js';
+import { SearchService } from '../../search/search-service.js';
+import 'json-schema';
+import 'zod';
+import '../../storage/backend/database-backend.js';
+import '../../search/types.js';
+import '../../context/types.js';
+import '../../llm/types.js';
+
+/**
+ * Services available to internal tools
+ * Add new services here as needed for internal tools
+ */
+interface InternalToolsServices {
+    searchService?: SearchService;
+}
+/**
+ * Internal tool factory function type
+ */
+type InternalToolFactory = (services: InternalToolsServices) => InternalTool;
+/**
+ * Internal tool names - Manual array preserves literal types for z.enum()
+ * Add new tool names here first, then implement in registry below
+ */
+declare const INTERNAL_TOOL_NAMES: readonly ["search_history"];
+/**
+ * Derive type from names array - preserves literal union
+ */
+type KnownInternalTool = (typeof INTERNAL_TOOL_NAMES)[number];
+/**
+ * Internal tool registry - Must match names array exactly (TypeScript enforces this)
+ */
+declare const INTERNAL_TOOL_REGISTRY: Record<KnownInternalTool, {
+    factory: InternalToolFactory;
+    requiredServices: readonly (keyof InternalToolsServices)[];
+}>;
+/**
+ * Type-safe registry access
+ */
+declare function getInternalToolInfo(toolName: KnownInternalTool): {
+    factory: InternalToolFactory;
+    requiredServices: readonly (keyof InternalToolsServices)[];
+};
+
+export { INTERNAL_TOOL_NAMES, INTERNAL_TOOL_REGISTRY, type InternalToolsServices, type KnownInternalTool, getInternalToolInfo };

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

@@ -0,0 +1,17 @@
+import { createSearchHistoryTool } from "./implementations/search-history-tool.js";
+const INTERNAL_TOOL_NAMES = ["search_history"];
+const INTERNAL_TOOL_REGISTRY = {
+  search_history: {
+    factory: (services) => createSearchHistoryTool(services.searchService),
+    requiredServices: ["searchService"]
+  }
+  // Add new tools here - must match INTERNAL_TOOL_NAMES array above
+};
+function getInternalToolInfo(toolName) {
+  return INTERNAL_TOOL_REGISTRY[toolName];
+}
+export {
+  INTERNAL_TOOL_NAMES,
+  INTERNAL_TOOL_REGISTRY,
+  getInternalToolInfo
+};