@stackmemoryai/stackmemory 0.5.58 → 0.5.61

package/dist/src/core/execution/parallel-executor.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/core/execution/parallel-executor.ts"],
+  "sourcesContent": ["/**\n * Parallel Execution Engine for RLM\n * \n * Manages concurrent execution of multiple Claude API calls\n * with rate limiting, resource pooling, and failure recovery\n */\n\nimport { EventEmitter } from 'events';\nimport { logger } from '../monitoring/logger.js';\n\nexport interface ExecutionTask<T> {\n  id: string;\n  execute: () => Promise<T>;\n  priority?: number;\n  timeout?: number;\n  retries?: number;\n}\n\nexport interface ExecutionResult<T> {\n  taskId: string;\n  success: boolean;\n  result?: T;\n  error?: Error;\n  duration: number;\n  attempts: number;\n}\n\nexport interface ParallelExecutorOptions {\n  maxConcurrency?: number;\n  queueSize?: number;\n  defaultTimeout?: number;\n  defaultRetries?: number;\n  rateLimitPerMinute?: number;\n}\n\n/**\n * Parallel Executor for managing concurrent operations\n */\nexport class ParallelExecutor extends EventEmitter {\n  private maxConcurrency: number;\n  private queueSize: number;\n  private defaultTimeout: number;\n  private defaultRetries: number;\n  private rateLimitPerMinute: number;\n  \n  private activeCount: number = 0;\n  private queue: ExecutionTask<any>[] = [];\n  private rateLimitTokens: number;\n  private lastRateLimitReset: number;\n  \n  // Metrics\n  private totalExecuted: number = 0;\n  private totalSucceeded: number = 0;\n  private totalFailed: number = 0;\n  private totalDuration: number = 0;\n\n  constructor(maxConcurrency: number = 5, options: ParallelExecutorOptions = {}) {\n    super();\n    \n    this.maxConcurrency = maxConcurrency;\n    this.queueSize = options.queueSize || 100;\n    this.defaultTimeout = options.defaultTimeout || 300000; // 5 minutes\n    this.defaultRetries = options.defaultRetries || 3;\n    this.rateLimitPerMinute = options.rateLimitPerMinute || 60;\n    \n    this.rateLimitTokens = this.rateLimitPerMinute;\n    this.lastRateLimitReset = Date.now();\n    \n    logger.info('Parallel Executor initialized', {\n      maxConcurrency,\n      queueSize: this.queueSize,\n      rateLimitPerMinute: this.rateLimitPerMinute,\n    });\n  }\n  \n  /**\n   * Execute multiple tasks in parallel\n   */\n  async executeParallel<T>(\n    items: T[],\n    executor: (item: T, index: number) => Promise<void>,\n    options?: {\n      batchSize?: number;\n      delayBetweenBatches?: number;\n    }\n  ): Promise<ExecutionResult<void>[]> {\n    const results: ExecutionResult<void>[] = [];\n    const batchSize = options?.batchSize || this.maxConcurrency;\n    const delayBetweenBatches = options?.delayBetweenBatches || 0;\n    \n    // Process items in batches\n    for (let i = 0; i < items.length; i += batchSize) {\n      const batch = items.slice(i, i + batchSize);\n      const batchPromises = batch.map((item, index) => \n        this.executeWithTracking(\n          `parallel-${i + index}`,\n          () => executor(item, i + index)\n        )\n      );\n      \n      const batchResults = await Promise.allSettled(batchPromises);\n      \n      // Convert to ExecutionResult format\n      batchResults.forEach((result, index) => {\n        if (result.status === 'fulfilled') {\n          results.push(result.value);\n        } else {\n          results.push({\n            taskId: `parallel-${i + index}`,\n            success: false,\n            error: result.reason,\n            duration: 0,\n            attempts: 1,\n          });\n        }\n      });\n      \n      // Delay between batches if specified\n      if (delayBetweenBatches > 0 && i + batchSize < items.length) {\n        await this.delay(delayBetweenBatches);\n      }\n      \n      // Log batch progress\n      logger.debug('Batch completed', {\n        batchNumber: Math.floor(i / batchSize) + 1,\n        totalBatches: Math.ceil(items.length / batchSize),\n        successRate: results.filter(r => r.success).length / results.length,\n      });\n    }\n    \n    return results;\n  }\n  \n  /**\n   * Execute a single task with tracking and retries\n   */\n  async executeWithTracking<T>(\n    taskId: string,\n    executor: () => Promise<T>,\n    options?: {\n      timeout?: number;\n      retries?: number;\n    }\n  ): Promise<ExecutionResult<T>> {\n    const timeout = options?.timeout || this.defaultTimeout;\n    const maxRetries = options?.retries || this.defaultRetries;\n    \n    let attempts = 0;\n    let lastError: Error | undefined;\n    const startTime = Date.now();\n    \n    while (attempts < maxRetries) {\n      attempts++;\n      \n      try {\n        // Check rate limit\n        await this.checkRateLimit();\n        \n        // Wait for available slot\n        await this.waitForSlot();\n        \n        this.activeCount++;\n        this.emit('task-start', { taskId, attempt: attempts });\n        \n        // Execute with timeout\n        const result = await this.executeWithTimeout(executor, timeout);\n        \n        // Success\n        this.totalSucceeded++;\n        this.emit('task-success', { taskId, attempts });\n        \n        return {\n          taskId,\n          success: true,\n          result,\n          duration: Date.now() - startTime,\n          attempts,\n        };\n        \n      } catch (error) {\n        lastError = error as Error;\n        \n        logger.warn(`Task failed (attempt ${attempts}/${maxRetries})`, {\n          taskId,\n          error: lastError.message,\n        });\n        \n        this.emit('task-retry', { taskId, attempt: attempts, error: lastError });\n        \n        // Exponential backoff for retries\n        if (attempts < maxRetries) {\n          await this.delay(Math.pow(2, attempts) * 1000);\n        }\n        \n      } finally {\n        this.activeCount--;\n        this.totalExecuted++;\n        this.totalDuration += Date.now() - startTime;\n      }\n    }\n    \n    // All retries exhausted\n    this.totalFailed++;\n    this.emit('task-failed', { taskId, attempts, error: lastError });\n    \n    return {\n      taskId,\n      success: false,\n      error: lastError,\n      duration: Date.now() - startTime,\n      attempts,\n    };\n  }\n  \n  /**\n   * Execute task with timeout\n   */\n  private async executeWithTimeout<T>(\n    executor: () => Promise<T>,\n    timeout: number\n  ): Promise<T> {\n    return Promise.race([\n      executor(),\n      new Promise<T>((_, reject) => \n        setTimeout(() => reject(new Error('Task timeout')), timeout)\n      ),\n    ]);\n  }\n  \n  /**\n   * Check and enforce rate limiting\n   */\n  private async checkRateLimit(): Promise<void> {\n    const now = Date.now();\n    const timeSinceReset = now - this.lastRateLimitReset;\n    \n    // Reset tokens if a minute has passed\n    if (timeSinceReset >= 60000) {\n      this.rateLimitTokens = this.rateLimitPerMinute;\n      this.lastRateLimitReset = now;\n    }\n    \n    // Wait if no tokens available\n    if (this.rateLimitTokens <= 0) {\n      const waitTime = 60000 - timeSinceReset;\n      logger.debug(`Rate limit reached, waiting ${waitTime}ms`);\n      await this.delay(waitTime);\n      \n      // Reset after waiting\n      this.rateLimitTokens = this.rateLimitPerMinute;\n      this.lastRateLimitReset = Date.now();\n    }\n    \n    this.rateLimitTokens--;\n  }\n  \n  /**\n   * Wait for an available execution slot\n   */\n  private async waitForSlot(): Promise<void> {\n    while (this.activeCount >= this.maxConcurrency) {\n      await this.delay(100); // Check every 100ms\n    }\n  }\n  \n  /**\n   * Queue a task for execution\n   */\n  async queueTask<T>(task: ExecutionTask<T>): Promise<ExecutionResult<T>> {\n    if (this.queue.length >= this.queueSize) {\n      throw new Error('Execution queue is full');\n    }\n    \n    return new Promise((resolve) => {\n      this.queue.push({\n        ...task,\n        execute: async () => {\n          const result = await task.execute();\n          resolve({\n            taskId: task.id,\n            success: true,\n            result,\n            duration: 0,\n            attempts: 1,\n          });\n          return result;\n        },\n      });\n      \n      this.processQueue();\n    });\n  }\n  \n  /**\n   * Process queued tasks\n   */\n  private async processQueue(): Promise<void> {\n    if (this.activeCount >= this.maxConcurrency || this.queue.length === 0) {\n      return;\n    }\n    \n    // Sort by priority (higher first)\n    this.queue.sort((a, b) => (b.priority || 0) - (a.priority || 0));\n    \n    const task = this.queue.shift();\n    if (task) {\n      this.executeWithTracking(task.id, task.execute, {\n        timeout: task.timeout,\n        retries: task.retries,\n      }).then(() => {\n        this.processQueue(); // Process next task\n      });\n    }\n  }\n  \n  /**\n   * Utility delay function\n   */\n  private delay(ms: number): Promise<void> {\n    return new Promise(resolve => setTimeout(resolve, ms));\n  }\n  \n  /**\n   * Get execution metrics\n   */\n  getMetrics() {\n    return {\n      activeCount: this.activeCount,\n      queueLength: this.queue.length,\n      totalExecuted: this.totalExecuted,\n      totalSucceeded: this.totalSucceeded,\n      totalFailed: this.totalFailed,\n      successRate: this.totalExecuted > 0 ? this.totalSucceeded / this.totalExecuted : 0,\n      averageDuration: this.totalExecuted > 0 ? this.totalDuration / this.totalExecuted : 0,\n      rateLimitTokens: this.rateLimitTokens,\n    };\n  }\n  \n  /**\n   * Reset all metrics\n   */\n  resetMetrics(): void {\n    this.totalExecuted = 0;\n    this.totalSucceeded = 0;\n    this.totalFailed = 0;\n    this.totalDuration = 0;\n  }\n  \n  /**\n   * Gracefully shutdown executor\n   */\n  async shutdown(): Promise<void> {\n    logger.info('Shutting down Parallel Executor', {\n      activeCount: this.activeCount,\n      queueLength: this.queue.length,\n    });\n    \n    // Clear queue\n    this.queue = [];\n    \n    // Wait for active tasks to complete\n    while (this.activeCount > 0) {\n      await this.delay(100);\n    }\n    \n    logger.info('Parallel Executor shutdown complete');\n  }\n}"],
+  "mappings": "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",
+  "names": []
+}

package/dist/src/core/extensions/custom-tools.js

@@ -0,0 +1,567 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { z } from "zod";
+import { v4 as uuidv4 } from "uuid";
+import { logger } from "../monitoring/logger.js";
+import {
+  ValidationError,
+  ErrorCode,
+  StackMemoryError,
+  SystemError
+} from "../errors/index.js";
+const ToolNameSchema = z.string().min(3, "Tool name must be at least 3 characters").max(64, "Tool name must be at most 64 characters").regex(
+  /^[a-z][a-z0-9_]*$/,
+  "Tool name must start with lowercase letter and contain only lowercase letters, numbers, and underscores"
+);
+const JSONSchemaPropertySchema = z.lazy(
+  () => z.object({
+    type: z.enum(["string", "number", "boolean", "array", "object", "null"]),
+    description: z.string().optional(),
+    enum: z.array(z.union([z.string(), z.number(), z.boolean()])).optional(),
+    default: z.unknown().optional(),
+    minimum: z.number().optional(),
+    maximum: z.number().optional(),
+    minLength: z.number().optional(),
+    maxLength: z.number().optional(),
+    pattern: z.string().optional(),
+    items: JSONSchemaPropertySchema.optional(),
+    properties: z.record(JSONSchemaPropertySchema).optional(),
+    required: z.array(z.string()).optional(),
+    format: z.string().optional()
+  })
+);
+const JSONSchemaSchema = z.object({
+  type: z.literal("object"),
+  properties: z.record(JSONSchemaPropertySchema).optional(),
+  required: z.array(z.string()).optional(),
+  additionalProperties: z.boolean().optional(),
+  description: z.string().optional(),
+  default: z.unknown().optional()
+});
+const ToolMetadataSchema = z.object({
+  version: z.string().optional(),
+  author: z.string().optional(),
+  category: z.string().optional(),
+  tags: z.array(z.string()).optional(),
+  timeout: z.number().min(100).max(3e5).optional(),
+  permissions: z.array(z.string()).optional()
+}).optional();
+class ToolRegistry {
+  tools = /* @__PURE__ */ new Map();
+  eventListeners = /* @__PURE__ */ new Map();
+  extensionStorage = /* @__PURE__ */ new Map();
+  defaultTimeout = 3e4;
+  // 30 seconds
+  constructor(options) {
+    if (options?.defaultTimeout) {
+      this.defaultTimeout = options.defaultTimeout;
+    }
+    logger.info("ToolRegistry initialized");
+  }
+  // ============================================
+  // Registration
+  // ============================================
+  /**
+   * Register a new custom tool
+   * @throws ValidationError if tool definition is invalid
+   * @throws StackMemoryError if tool with same name already exists
+   */
+  register(definition) {
+    this.validateToolDefinition(definition);
+    if (this.tools.has(definition.name)) {
+      throw new StackMemoryError({
+        code: ErrorCode.VALIDATION_FAILED,
+        message: `Tool '${definition.name}' is already registered`,
+        context: { toolName: definition.name }
+      });
+    }
+    const toolId = uuidv4();
+    const registeredTool = {
+      ...definition,
+      id: toolId,
+      registeredAt: /* @__PURE__ */ new Date(),
+      usageCount: 0,
+      enabled: true
+    };
+    this.tools.set(definition.name, registeredTool);
+    logger.info("Tool registered", {
+      toolId,
+      name: definition.name,
+      category: definition.metadata?.category
+    });
+    return toolId;
+  }
+  /**
+   * Unregister a tool by name
+   */
+  unregister(name) {
+    const tool = this.tools.get(name);
+    if (!tool) {
+      return false;
+    }
+    this.tools.delete(name);
+    this.extensionStorage.delete(name);
+    logger.info("Tool unregistered", { name, toolId: tool.id });
+    return true;
+  }
+  /**
+   * Update an existing tool definition
+   */
+  update(name, updates) {
+    const tool = this.tools.get(name);
+    if (!tool) {
+      return false;
+    }
+    if (updates.parameters) {
+      const result = JSONSchemaSchema.safeParse(updates.parameters);
+      if (!result.success) {
+        throw new ValidationError(
+          `Invalid parameters schema: ${result.error.message}`,
+          ErrorCode.VALIDATION_FAILED,
+          { errors: result.error.errors }
+        );
+      }
+    }
+    Object.assign(tool, updates);
+    logger.info("Tool updated", { name, toolId: tool.id });
+    return true;
+  }
+  // ============================================
+  // Discovery
+  // ============================================
+  /**
+   * Get a tool by name
+   */
+  get(name) {
+    return this.tools.get(name);
+  }
+  /**
+   * List all registered tools
+   */
+  list(filter) {
+    let tools = Array.from(this.tools.values());
+    if (filter?.category) {
+      tools = tools.filter((t) => t.metadata?.category === filter.category);
+    }
+    if (filter?.tags && filter.tags.length > 0) {
+      tools = tools.filter(
+        (t) => filter.tags.some((tag) => t.metadata?.tags?.includes(tag))
+      );
+    }
+    if (filter?.enabled !== void 0) {
+      tools = tools.filter((t) => t.enabled === filter.enabled);
+    }
+    return tools;
+  }
+  /**
+   * Get tool definitions in MCP format
+   */
+  getMCPToolDefinitions() {
+    return Array.from(this.tools.values()).filter((t) => t.enabled).map((t) => ({
+      name: t.name,
+      description: t.description,
+      inputSchema: t.parameters
+    }));
+  }
+  /**
+   * Check if a tool exists
+   */
+  has(name) {
+    return this.tools.has(name);
+  }
+  /**
+   * Get tool count
+   */
+  get size() {
+    return this.tools.size;
+  }
+  // ============================================
+  // Execution
+  // ============================================
+  /**
+   * Execute a tool with sandboxed context
+   */
+  async execute(name, params, options) {
+    const tool = this.tools.get(name);
+    if (!tool) {
+      return {
+        success: false,
+        error: `Tool '${name}' not found`
+      };
+    }
+    if (!tool.enabled) {
+      return {
+        success: false,
+        error: `Tool '${name}' is disabled`
+      };
+    }
+    const validationResult = this.validateParams(params, tool.parameters);
+    if (!validationResult.valid) {
+      return {
+        success: false,
+        error: `Invalid parameters: ${validationResult.errors.join(", ")}`
+      };
+    }
+    const context = this.createSandboxedContext(name, options?.context);
+    const timeout = options?.timeout ?? tool.metadata?.timeout ?? this.defaultTimeout;
+    try {
+      const result = await this.executeWithSandbox(
+        () => tool.execute(params, context),
+        timeout,
+        options?.sandboxed ?? true
+      );
+      tool.lastUsedAt = /* @__PURE__ */ new Date();
+      tool.usageCount++;
+      logger.info("Tool executed successfully", {
+        name,
+        toolId: tool.id,
+        duration: Date.now() - tool.lastUsedAt.getTime()
+      });
+      return result;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      logger.error("Tool execution failed", {
+        name,
+        toolId: tool.id,
+        error: message
+      });
+      return {
+        success: false,
+        error: message,
+        metadata: { toolId: tool.id }
+      };
+    }
+  }
+  // ============================================
+  // Private Methods
+  // ============================================
+  /**
+   * Validate a tool definition before registration
+   */
+  validateToolDefinition(definition) {
+    const nameResult = ToolNameSchema.safeParse(definition.name);
+    if (!nameResult.success) {
+      throw new ValidationError(
+        `Invalid tool name: ${nameResult.error.message}`,
+        ErrorCode.VALIDATION_FAILED,
+        { name: definition.name, errors: nameResult.error.errors }
+      );
+    }
+    if (!definition.description || definition.description.length < 10) {
+      throw new ValidationError(
+        "Tool description must be at least 10 characters",
+        ErrorCode.VALIDATION_FAILED,
+        { description: definition.description }
+      );
+    }
+    if (definition.description.length > 500) {
+      throw new ValidationError(
+        "Tool description must be at most 500 characters",
+        ErrorCode.VALIDATION_FAILED,
+        { descriptionLength: definition.description.length }
+      );
+    }
+    const schemaResult = JSONSchemaSchema.safeParse(definition.parameters);
+    if (!schemaResult.success) {
+      throw new ValidationError(
+        `Invalid parameters schema: ${schemaResult.error.message}`,
+        ErrorCode.VALIDATION_FAILED,
+        { errors: schemaResult.error.errors }
+      );
+    }
+    if (typeof definition.execute !== "function") {
+      throw new ValidationError(
+        "Tool execute must be a function",
+        ErrorCode.VALIDATION_FAILED
+      );
+    }
+    if (definition.metadata) {
+      const metaResult = ToolMetadataSchema.safeParse(definition.metadata);
+      if (!metaResult.success) {
+        throw new ValidationError(
+          `Invalid tool metadata: ${metaResult.error.message}`,
+          ErrorCode.VALIDATION_FAILED,
+          { errors: metaResult.error.errors }
+        );
+      }
+    }
+  }
+  /**
+   * Validate parameters against JSON Schema
+   */
+  validateParams(params, schema) {
+    const errors = [];
+    if (schema.type !== "object") {
+      errors.push('Parameters schema must have type "object"');
+      return { valid: false, errors };
+    }
+    if (params === null || params === void 0) {
+      if (schema.required && schema.required.length > 0) {
+        errors.push(
+          `Missing required parameters: ${schema.required.join(", ")}`
+        );
+      }
+      return { valid: errors.length === 0, errors };
+    }
+    if (typeof params !== "object" || Array.isArray(params)) {
+      errors.push("Parameters must be an object");
+      return { valid: false, errors };
+    }
+    const paramObj = params;
+    if (schema.required) {
+      for (const field of schema.required) {
+        if (!(field in paramObj)) {
+          errors.push(`Missing required parameter: ${field}`);
+        }
+      }
+    }
+    if (schema.properties) {
+      for (const [key, propSchema] of Object.entries(schema.properties)) {
+        if (key in paramObj) {
+          const propErrors = this.validateProperty(
+            paramObj[key],
+            propSchema,
+            key
+          );
+          errors.push(...propErrors);
+        }
+      }
+      if (schema.additionalProperties === false) {
+        for (const key of Object.keys(paramObj)) {
+          if (!(key in schema.properties)) {
+            errors.push(`Unknown parameter: ${key}`);
+          }
+        }
+      }
+    }
+    return { valid: errors.length === 0, errors };
+  }
+  /**
+   * Validate a single property value
+   */
+  validateProperty(value, schema, path) {
+    const errors = [];
+    const actualType = this.getJSONType(value);
+    if (actualType !== schema.type && value !== void 0 && value !== null) {
+      if (!(schema.type === "null" && value === null)) {
+        errors.push(
+          `Parameter '${path}' must be of type ${schema.type}, got ${actualType}`
+        );
+      }
+    }
+    if (schema.type === "string" && typeof value === "string") {
+      if (schema.minLength !== void 0 && value.length < schema.minLength) {
+        errors.push(
+          `Parameter '${path}' must be at least ${schema.minLength} characters`
+        );
+      }
+      if (schema.maxLength !== void 0 && value.length > schema.maxLength) {
+        errors.push(
+          `Parameter '${path}' must be at most ${schema.maxLength} characters`
+        );
+      }
+      if (schema.pattern && !new RegExp(schema.pattern).test(value)) {
+        errors.push(
+          `Parameter '${path}' does not match pattern ${schema.pattern}`
+        );
+      }
+      if (schema.enum && !schema.enum.includes(value)) {
+        errors.push(
+          `Parameter '${path}' must be one of: ${schema.enum.join(", ")}`
+        );
+      }
+    }
+    if (schema.type === "number" && typeof value === "number") {
+      if (schema.minimum !== void 0 && value < schema.minimum) {
+        errors.push(`Parameter '${path}' must be at least ${schema.minimum}`);
+      }
+      if (schema.maximum !== void 0 && value > schema.maximum) {
+        errors.push(`Parameter '${path}' must be at most ${schema.maximum}`);
+      }
+      if (schema.enum && !schema.enum.includes(value)) {
+        errors.push(
+          `Parameter '${path}' must be one of: ${schema.enum.join(", ")}`
+        );
+      }
+    }
+    if (schema.type === "array" && Array.isArray(value) && schema.items) {
+      value.forEach((item, index) => {
+        const itemErrors = this.validateProperty(
+          item,
+          schema.items,
+          `${path}[${index}]`
+        );
+        errors.push(...itemErrors);
+      });
+    }
+    return errors;
+  }
+  /**
+   * Get JSON type of a value
+   */
+  getJSONType(value) {
+    if (value === null) return "null";
+    if (Array.isArray(value)) return "array";
+    return typeof value;
+  }
+  /**
+   * Create a sandboxed extension context
+   */
+  createSandboxedContext(toolName, overrides) {
+    if (!this.extensionStorage.has(toolName)) {
+      this.extensionStorage.set(toolName, /* @__PURE__ */ new Map());
+    }
+    const storage = this.extensionStorage.get(toolName);
+    const context = {
+      projectId: overrides?.projectId ?? "sandbox",
+      sessionId: overrides?.sessionId ?? uuidv4(),
+      runId: overrides?.runId ?? uuidv4(),
+      // Sandboxed fetch (could add URL allowlist here)
+      fetch: globalThis.fetch,
+      // Extension storage
+      storage: {
+        async get(key) {
+          return storage.get(key);
+        },
+        async set(key, value) {
+          storage.set(key, value);
+        },
+        async delete(key) {
+          storage.delete(key);
+        },
+        async clear() {
+          storage.clear();
+        }
+      },
+      // Event communication
+      emit: (event, data) => {
+        const listeners = this.eventListeners.get(event);
+        if (listeners) {
+          listeners.forEach((handler) => {
+            try {
+              handler(data);
+            } catch (error) {
+              logger.error("Event handler error", {
+                event,
+                error: error instanceof Error ? error.message : String(error)
+              });
+            }
+          });
+        }
+      },
+      on: (event, handler) => {
+        if (!this.eventListeners.has(event)) {
+          this.eventListeners.set(event, /* @__PURE__ */ new Set());
+        }
+        this.eventListeners.get(event).add(handler);
+        return () => {
+          this.eventListeners.get(event)?.delete(handler);
+        };
+      },
+      // Sandboxed logging
+      log: {
+        info: (message, meta) => {
+          logger.info(`[Tool:${toolName}] ${message}`, meta);
+        },
+        warn: (message, meta) => {
+          logger.warn(`[Tool:${toolName}] ${message}`, meta);
+        },
+        error: (message, meta) => {
+          logger.error(`[Tool:${toolName}] ${message}`, meta);
+        }
+      }
+    };
+    return context;
+  }
+  /**
+   * Execute tool with sandbox wrapper and timeout
+   */
+  async executeWithSandbox(executor, timeout, sandboxed) {
+    const timeoutPromise = new Promise((_, reject) => {
+      setTimeout(() => {
+        reject(
+          new SystemError(
+            `Tool execution timed out after ${timeout}ms`,
+            ErrorCode.OPERATION_TIMEOUT
+          )
+        );
+      }, timeout);
+    });
+    const executionPromise = (async () => {
+      try {
+        if (sandboxed) {
+          return await Promise.resolve(executor());
+        } else {
+          return await Promise.resolve(executor());
+        }
+      } catch (error) {
+        if (error instanceof StackMemoryError) {
+          throw error;
+        }
+        throw new SystemError(
+          `Tool execution error: ${error instanceof Error ? error.message : String(error)}`,
+          ErrorCode.MCP_EXECUTION_FAILED,
+          { error: String(error) }
+        );
+      }
+    })();
+    return Promise.race([executionPromise, timeoutPromise]);
+  }
+  /**
+   * Clear all event listeners
+   */
+  clearEventListeners() {
+    this.eventListeners.clear();
+  }
+  /**
+   * Get statistics about registered tools
+   */
+  getStats() {
+    const tools = Array.from(this.tools.values());
+    const byCategory = {};
+    for (const tool of tools) {
+      const category = tool.metadata?.category ?? "uncategorized";
+      byCategory[category] = (byCategory[category] ?? 0) + 1;
+    }
+    return {
+      totalTools: tools.length,
+      enabledTools: tools.filter((t) => t.enabled).length,
+      totalExecutions: tools.reduce((sum, t) => sum + t.usageCount, 0),
+      byCategory
+    };
+  }
+  /**
+   * Enable or disable a tool
+   */
+  setEnabled(name, enabled) {
+    const tool = this.tools.get(name);
+    if (!tool) {
+      return false;
+    }
+    tool.enabled = enabled;
+    logger.info(`Tool ${enabled ? "enabled" : "disabled"}`, { name });
+    return true;
+  }
+}
+function createToolRegistry(options) {
+  return new ToolRegistry(options);
+}
+function defineTool(name, description, parameters, execute, metadata) {
+  return {
+    name,
+    description,
+    parameters,
+    execute,
+    metadata
+  };
+}
+var custom_tools_default = ToolRegistry;
+export {
+  ToolRegistry,
+  createToolRegistry,
+  custom_tools_default as default,
+  defineTool
+};
+//# sourceMappingURL=custom-tools.js.map