@dexto/core 1.1.4 → 1.1.6

package/dist/tools/errors.cjs

@@ -0,0 +1,164 @@
+"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 errors_exports = {};
+__export(errors_exports, {
+  ToolError: () => ToolError
+});
+module.exports = __toCommonJS(errors_exports);
+var import_DextoRuntimeError = require("../errors/DextoRuntimeError.cjs");
+var import_types = require("../errors/types.cjs");
+var import_error_codes = require("./error-codes.js");
+class ToolError {
+  /**
+   * Tool not found error
+   */
+  static notFound(toolName) {
+    return new import_DextoRuntimeError.DextoRuntimeError(
+      import_error_codes.ToolErrorCode.TOOL_NOT_FOUND,
+      import_types.ErrorScope.TOOLS,
+      import_types.ErrorType.NOT_FOUND,
+      `Tool '${toolName}' not found`,
+      { toolName }
+    );
+  }
+  /**
+   * Tool execution failed
+   */
+  static executionFailed(toolName, reason, sessionId) {
+    return new import_DextoRuntimeError.DextoRuntimeError(
+      import_error_codes.ToolErrorCode.EXECUTION_FAILED,
+      import_types.ErrorScope.TOOLS,
+      import_types.ErrorType.SYSTEM,
+      `Tool '${toolName}' execution failed: ${reason}`,
+      { toolName, reason, sessionId }
+    );
+  }
+  /**
+   * Tool execution denied by user/policy
+   */
+  static executionDenied(toolName, sessionId) {
+    return new import_DextoRuntimeError.DextoRuntimeError(
+      import_error_codes.ToolErrorCode.EXECUTION_DENIED,
+      import_types.ErrorScope.TOOLS,
+      import_types.ErrorType.FORBIDDEN,
+      `Tool '${toolName}' execution was denied by the user`,
+      { toolName, sessionId }
+    );
+  }
+  /**
+   * Tool execution timeout
+   */
+  static executionTimeout(toolName, timeoutMs, sessionId) {
+    return new import_DextoRuntimeError.DextoRuntimeError(
+      import_error_codes.ToolErrorCode.EXECUTION_TIMEOUT,
+      import_types.ErrorScope.TOOLS,
+      import_types.ErrorType.TIMEOUT,
+      `Tool '${toolName}' execution timed out after ${timeoutMs}ms`,
+      { toolName, timeoutMs, sessionId }
+    );
+  }
+  /**
+   * Tool unauthorized access
+   */
+  static unauthorized(toolName, sessionId) {
+    return new import_DextoRuntimeError.DextoRuntimeError(
+      import_error_codes.ToolErrorCode.TOOL_UNAUTHORIZED,
+      import_types.ErrorScope.TOOLS,
+      import_types.ErrorType.FORBIDDEN,
+      `Unauthorized access to tool '${toolName}'`,
+      { toolName, sessionId }
+    );
+  }
+  /**
+   * Confirmation handler missing
+   */
+  static confirmationHandlerMissing(toolName) {
+    return new import_DextoRuntimeError.DextoRuntimeError(
+      import_error_codes.ToolErrorCode.CONFIRMATION_HANDLER_MISSING,
+      import_types.ErrorScope.TOOLS,
+      import_types.ErrorType.SYSTEM,
+      `Confirmation handler missing for tool '${toolName}'`,
+      { toolName }
+    );
+  }
+  /**
+   * Confirmation timeout
+   */
+  static confirmationTimeout(toolName, timeoutMs, sessionId) {
+    return new import_DextoRuntimeError.DextoRuntimeError(
+      import_error_codes.ToolErrorCode.CONFIRMATION_TIMEOUT,
+      import_types.ErrorScope.TOOLS,
+      import_types.ErrorType.TIMEOUT,
+      `Tool '${toolName}' confirmation timed out after ${timeoutMs}ms`,
+      { toolName, timeoutMs, sessionId }
+    );
+  }
+  /**
+   * Invalid tool name (semantic validation - empty name after prefix, malformed, etc.)
+   */
+  static invalidName(toolName, reason) {
+    return new import_DextoRuntimeError.DextoRuntimeError(
+      import_error_codes.ToolErrorCode.TOOL_INVALID_ARGS,
+      import_types.ErrorScope.TOOLS,
+      import_types.ErrorType.USER,
+      `Invalid tool name '${toolName}': ${reason}`,
+      { toolName, reason }
+    );
+  }
+  /**
+   * Internal tools provider not initialized
+   */
+  static internalToolsNotInitialized(toolName) {
+    return new import_DextoRuntimeError.DextoRuntimeError(
+      import_error_codes.ToolErrorCode.EXECUTION_FAILED,
+      import_types.ErrorScope.TOOLS,
+      import_types.ErrorType.SYSTEM,
+      `Internal tools not initialized, cannot execute: ${toolName}`,
+      { toolName }
+    );
+  }
+  /**
+   * Invalid tool configuration
+   */
+  static configInvalid(message) {
+    return new import_DextoRuntimeError.DextoRuntimeError(
+      import_error_codes.ToolErrorCode.CONFIG_INVALID,
+      import_types.ErrorScope.TOOLS,
+      import_types.ErrorType.USER,
+      message,
+      {}
+    );
+  }
+  /**
+   * Confirmation cancelled
+   */
+  static confirmationCancelled(toolName, reason) {
+    return new import_DextoRuntimeError.DextoRuntimeError(
+      import_error_codes.ToolErrorCode.CONFIRMATION_CANCELLED,
+      import_types.ErrorScope.TOOLS,
+      import_types.ErrorType.USER,
+      `Tool confirmation for '${toolName}' was cancelled: ${reason}`,
+      { toolName, reason }
+    );
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ToolError
+});

package/dist/tools/errors.d.cts

@@ -0,0 +1,97 @@
+import { DextoRuntimeError } from '../errors/DextoRuntimeError.cjs';
+import '../errors/DextoBaseError.cjs';
+import '../errors/types.cjs';
+import '../agent/error-codes.cjs';
+import '../config/error-codes.cjs';
+import '../context/error-codes.cjs';
+import '../llm/error-codes.cjs';
+import '../mcp/error-codes.cjs';
+import '../session/error-codes.cjs';
+import '../storage/error-codes.cjs';
+import '../systemPrompt/error-codes.cjs';
+import './error-codes.cjs';
+import '../preferences/error-codes.cjs';
+import '../agent/registry/error-codes.cjs';
+
+/**
+ * Tool error factory with typed methods for creating tool-specific errors
+ * Each method creates a properly typed DextoError with TOOLS scope
+ */
+declare class ToolError {
+    /**
+     * Tool not found error
+     */
+    static notFound(toolName: string): DextoRuntimeError<{
+        toolName: string;
+    }>;
+    /**
+     * Tool execution failed
+     */
+    static executionFailed(toolName: string, reason: string, sessionId?: string): DextoRuntimeError<{
+        toolName: string;
+        reason: string;
+        sessionId: string | undefined;
+    }>;
+    /**
+     * Tool execution denied by user/policy
+     */
+    static executionDenied(toolName: string, sessionId?: string): DextoRuntimeError<{
+        toolName: string;
+        sessionId: string | undefined;
+    }>;
+    /**
+     * Tool execution timeout
+     */
+    static executionTimeout(toolName: string, timeoutMs: number, sessionId?: string): DextoRuntimeError<{
+        toolName: string;
+        timeoutMs: number;
+        sessionId: string | undefined;
+    }>;
+    /**
+     * Tool unauthorized access
+     */
+    static unauthorized(toolName: string, sessionId?: string): DextoRuntimeError<{
+        toolName: string;
+        sessionId: string | undefined;
+    }>;
+    /**
+     * Confirmation handler missing
+     */
+    static confirmationHandlerMissing(toolName: string): DextoRuntimeError<{
+        toolName: string;
+    }>;
+    /**
+     * Confirmation timeout
+     */
+    static confirmationTimeout(toolName: string, timeoutMs: number, sessionId?: string): DextoRuntimeError<{
+        toolName: string;
+        timeoutMs: number;
+        sessionId: string | undefined;
+    }>;
+    /**
+     * Invalid tool name (semantic validation - empty name after prefix, malformed, etc.)
+     */
+    static invalidName(toolName: string, reason: string): DextoRuntimeError<{
+        toolName: string;
+        reason: string;
+    }>;
+    /**
+     * Internal tools provider not initialized
+     */
+    static internalToolsNotInitialized(toolName: string): DextoRuntimeError<{
+        toolName: string;
+    }>;
+    /**
+     * Invalid tool configuration
+     */
+    static configInvalid(message: string): DextoRuntimeError<{}>;
+    /**
+     * Confirmation cancelled
+     */
+    static confirmationCancelled(toolName: string, reason: string): DextoRuntimeError<{
+        toolName: string;
+        reason: string;
+    }>;
+}
+
+export { ToolError };

package/dist/tools/errors.d.ts

@@ -0,0 +1,97 @@
+import { DextoRuntimeError } from '../errors/DextoRuntimeError.js';
+import '../errors/DextoBaseError.js';
+import '../errors/types.js';
+import '../agent/error-codes.js';
+import '../config/error-codes.js';
+import '../context/error-codes.js';
+import '../llm/error-codes.js';
+import '../mcp/error-codes.js';
+import '../session/error-codes.js';
+import '../storage/error-codes.js';
+import '../systemPrompt/error-codes.js';
+import './error-codes.js';
+import '../preferences/error-codes.js';
+import '../agent/registry/error-codes.js';
+
+/**
+ * Tool error factory with typed methods for creating tool-specific errors
+ * Each method creates a properly typed DextoError with TOOLS scope
+ */
+declare class ToolError {
+    /**
+     * Tool not found error
+     */
+    static notFound(toolName: string): DextoRuntimeError<{
+        toolName: string;
+    }>;
+    /**
+     * Tool execution failed
+     */
+    static executionFailed(toolName: string, reason: string, sessionId?: string): DextoRuntimeError<{
+        toolName: string;
+        reason: string;
+        sessionId: string | undefined;
+    }>;
+    /**
+     * Tool execution denied by user/policy
+     */
+    static executionDenied(toolName: string, sessionId?: string): DextoRuntimeError<{
+        toolName: string;
+        sessionId: string | undefined;
+    }>;
+    /**
+     * Tool execution timeout
+     */
+    static executionTimeout(toolName: string, timeoutMs: number, sessionId?: string): DextoRuntimeError<{
+        toolName: string;
+        timeoutMs: number;
+        sessionId: string | undefined;
+    }>;
+    /**
+     * Tool unauthorized access
+     */
+    static unauthorized(toolName: string, sessionId?: string): DextoRuntimeError<{
+        toolName: string;
+        sessionId: string | undefined;
+    }>;
+    /**
+     * Confirmation handler missing
+     */
+    static confirmationHandlerMissing(toolName: string): DextoRuntimeError<{
+        toolName: string;
+    }>;
+    /**
+     * Confirmation timeout
+     */
+    static confirmationTimeout(toolName: string, timeoutMs: number, sessionId?: string): DextoRuntimeError<{
+        toolName: string;
+        timeoutMs: number;
+        sessionId: string | undefined;
+    }>;
+    /**
+     * Invalid tool name (semantic validation - empty name after prefix, malformed, etc.)
+     */
+    static invalidName(toolName: string, reason: string): DextoRuntimeError<{
+        toolName: string;
+        reason: string;
+    }>;
+    /**
+     * Internal tools provider not initialized
+     */
+    static internalToolsNotInitialized(toolName: string): DextoRuntimeError<{
+        toolName: string;
+    }>;
+    /**
+     * Invalid tool configuration
+     */
+    static configInvalid(message: string): DextoRuntimeError<{}>;
+    /**
+     * Confirmation cancelled
+     */
+    static confirmationCancelled(toolName: string, reason: string): DextoRuntimeError<{
+        toolName: string;
+        reason: string;
+    }>;
+}
+
+export { ToolError };

package/dist/tools/errors.js

@@ -0,0 +1,140 @@
+import { DextoRuntimeError } from "../errors/DextoRuntimeError.js";
+import { ErrorScope, ErrorType } from "../errors/types.js";
+import { ToolErrorCode } from "./error-codes.js";
+class ToolError {
+  /**
+   * Tool not found error
+   */
+  static notFound(toolName) {
+    return new DextoRuntimeError(
+      ToolErrorCode.TOOL_NOT_FOUND,
+      ErrorScope.TOOLS,
+      ErrorType.NOT_FOUND,
+      `Tool '${toolName}' not found`,
+      { toolName }
+    );
+  }
+  /**
+   * Tool execution failed
+   */
+  static executionFailed(toolName, reason, sessionId) {
+    return new DextoRuntimeError(
+      ToolErrorCode.EXECUTION_FAILED,
+      ErrorScope.TOOLS,
+      ErrorType.SYSTEM,
+      `Tool '${toolName}' execution failed: ${reason}`,
+      { toolName, reason, sessionId }
+    );
+  }
+  /**
+   * Tool execution denied by user/policy
+   */
+  static executionDenied(toolName, sessionId) {
+    return new DextoRuntimeError(
+      ToolErrorCode.EXECUTION_DENIED,
+      ErrorScope.TOOLS,
+      ErrorType.FORBIDDEN,
+      `Tool '${toolName}' execution was denied by the user`,
+      { toolName, sessionId }
+    );
+  }
+  /**
+   * Tool execution timeout
+   */
+  static executionTimeout(toolName, timeoutMs, sessionId) {
+    return new DextoRuntimeError(
+      ToolErrorCode.EXECUTION_TIMEOUT,
+      ErrorScope.TOOLS,
+      ErrorType.TIMEOUT,
+      `Tool '${toolName}' execution timed out after ${timeoutMs}ms`,
+      { toolName, timeoutMs, sessionId }
+    );
+  }
+  /**
+   * Tool unauthorized access
+   */
+  static unauthorized(toolName, sessionId) {
+    return new DextoRuntimeError(
+      ToolErrorCode.TOOL_UNAUTHORIZED,
+      ErrorScope.TOOLS,
+      ErrorType.FORBIDDEN,
+      `Unauthorized access to tool '${toolName}'`,
+      { toolName, sessionId }
+    );
+  }
+  /**
+   * Confirmation handler missing
+   */
+  static confirmationHandlerMissing(toolName) {
+    return new DextoRuntimeError(
+      ToolErrorCode.CONFIRMATION_HANDLER_MISSING,
+      ErrorScope.TOOLS,
+      ErrorType.SYSTEM,
+      `Confirmation handler missing for tool '${toolName}'`,
+      { toolName }
+    );
+  }
+  /**
+   * Confirmation timeout
+   */
+  static confirmationTimeout(toolName, timeoutMs, sessionId) {
+    return new DextoRuntimeError(
+      ToolErrorCode.CONFIRMATION_TIMEOUT,
+      ErrorScope.TOOLS,
+      ErrorType.TIMEOUT,
+      `Tool '${toolName}' confirmation timed out after ${timeoutMs}ms`,
+      { toolName, timeoutMs, sessionId }
+    );
+  }
+  /**
+   * Invalid tool name (semantic validation - empty name after prefix, malformed, etc.)
+   */
+  static invalidName(toolName, reason) {
+    return new DextoRuntimeError(
+      ToolErrorCode.TOOL_INVALID_ARGS,
+      ErrorScope.TOOLS,
+      ErrorType.USER,
+      `Invalid tool name '${toolName}': ${reason}`,
+      { toolName, reason }
+    );
+  }
+  /**
+   * Internal tools provider not initialized
+   */
+  static internalToolsNotInitialized(toolName) {
+    return new DextoRuntimeError(
+      ToolErrorCode.EXECUTION_FAILED,
+      ErrorScope.TOOLS,
+      ErrorType.SYSTEM,
+      `Internal tools not initialized, cannot execute: ${toolName}`,
+      { toolName }
+    );
+  }
+  /**
+   * Invalid tool configuration
+   */
+  static configInvalid(message) {
+    return new DextoRuntimeError(
+      ToolErrorCode.CONFIG_INVALID,
+      ErrorScope.TOOLS,
+      ErrorType.USER,
+      message,
+      {}
+    );
+  }
+  /**
+   * Confirmation cancelled
+   */
+  static confirmationCancelled(toolName, reason) {
+    return new DextoRuntimeError(
+      ToolErrorCode.CONFIRMATION_CANCELLED,
+      ErrorScope.TOOLS,
+      ErrorType.USER,
+      `Tool confirmation for '${toolName}' was cancelled: ${reason}`,
+      { toolName, reason }
+    );
+  }
+}
+export {
+  ToolError
+};

package/dist/tools/index.cjs

@@ -0,0 +1,37 @@
+"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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var tools_exports = {};
+__export(tools_exports, {
+  ToolManager: () => import_tool_manager.ToolManager
+});
+module.exports = __toCommonJS(tools_exports);
+__reExport(tools_exports, require("./types.js"), module.exports);
+__reExport(tools_exports, require("./confirmation/types.js"), module.exports);
+__reExport(tools_exports, require("./internal-tools/index.js"), module.exports);
+__reExport(tools_exports, require("./schemas.js"), module.exports);
+var import_tool_manager = require("./tool-manager.js");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ToolManager,
+  ...require("./types.js"),
+  ...require("./confirmation/types.js"),
+  ...require("./internal-tools/index.js"),
+  ...require("./schemas.js")
+});

package/dist/tools/index.d.cts

@@ -0,0 +1,19 @@
+export { InternalTool, ToolCall, ToolExecutionContext, ToolProvider, ToolResult, ToolSet } from './types.cjs';
+export { ToolConfirmationEvent, ToolConfirmationProvider, ToolConfirmationResponse, ToolExecutionDetails } from './confirmation/types.cjs';
+export { InternalToolsProvider } from './internal-tools/provider.cjs';
+export { INTERNAL_TOOL_NAMES, INTERNAL_TOOL_REGISTRY, InternalToolsServices, KnownInternalTool, getInternalToolInfo } from './internal-tools/registry.cjs';
+export { InternalToolsConfig, InternalToolsSchema, ToolConfirmationConfig, ToolConfirmationConfigSchema, ValidatedToolConfirmationConfig } from './schemas.cjs';
+export { InternalToolsOptions, ToolManager } from './tool-manager.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';
+import '../mcp/manager.cjs';
+import '../mcp/schemas.cjs';
+import '../mcp/types.cjs';
+import '@modelcontextprotocol/sdk/client/index.js';
+import '@modelcontextprotocol/sdk/types.js';

package/dist/tools/index.d.ts

@@ -0,0 +1,19 @@
+export { InternalTool, ToolCall, ToolExecutionContext, ToolProvider, ToolResult, ToolSet } from './types.js';
+export { ToolConfirmationEvent, ToolConfirmationProvider, ToolConfirmationResponse, ToolExecutionDetails } from './confirmation/types.js';
+export { InternalToolsProvider } from './internal-tools/provider.js';
+export { INTERNAL_TOOL_NAMES, INTERNAL_TOOL_REGISTRY, InternalToolsServices, KnownInternalTool, getInternalToolInfo } from './internal-tools/registry.js';
+export { InternalToolsConfig, InternalToolsSchema, ToolConfirmationConfig, ToolConfirmationConfigSchema, ValidatedToolConfirmationConfig } from './schemas.js';
+export { InternalToolsOptions, ToolManager } from './tool-manager.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';
+import '../mcp/manager.js';
+import '../mcp/schemas.js';
+import '../mcp/types.js';
+import '@modelcontextprotocol/sdk/client/index.js';
+import '@modelcontextprotocol/sdk/types.js';

package/dist/tools/index.js

@@ -0,0 +1,8 @@
+export * from "./types.js";
+export * from "./confirmation/types.js";
+export * from "./internal-tools/index.js";
+export * from "./schemas.js";
+import { ToolManager } from "./tool-manager.js";
+export {
+  ToolManager
+};

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

@@ -0,0 +1,61 @@
+"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 search_history_tool_exports = {};
+__export(search_history_tool_exports, {
+  createSearchHistoryTool: () => createSearchHistoryTool
+});
+module.exports = __toCommonJS(search_history_tool_exports);
+var import_zod = require("zod");
+const SearchHistoryInputSchema = import_zod.z.object({
+  query: import_zod.z.string().describe("The search query to find in conversation history"),
+  mode: import_zod.z.enum(["messages", "sessions"]).describe(
+    'Search mode: "messages" searches for individual messages, "sessions" finds sessions containing the query'
+  ),
+  sessionId: import_zod.z.string().optional().describe('Optional: limit search to a specific session (only for mode="messages")'),
+  role: import_zod.z.enum(["user", "assistant", "system", "tool"]).optional().describe('Optional: filter by message role (only for mode="messages")'),
+  limit: import_zod.z.number().optional().default(20).describe(
+    'Optional: maximum number of results to return (default: 20, only for mode="messages")'
+  ),
+  offset: import_zod.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);
+      }
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createSearchHistoryTool
+});

package/dist/tools/internal-tools/implementations/search-history-tool.d.cts

@@ -0,0 +1,15 @@
+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';
+
+/**
+ * Internal tool for searching conversation history
+ */
+declare function createSearchHistoryTool(searchService: SearchService): InternalTool;
+
+export { createSearchHistoryTool };

package/dist/tools/internal-tools/implementations/search-history-tool.d.ts

@@ -0,0 +1,15 @@
+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';
+
+/**
+ * Internal tool for searching conversation history
+ */
+declare function createSearchHistoryTool(searchService: SearchService): InternalTool;
+
+export { createSearchHistoryTool };