@agentforge/core 0.16.43 → 0.16.45

package/dist/index.cjs

@@ -1482,7 +1482,155 @@ function createToolExecutor(config = {}) {
   };
 }
 
-// src/tools/lifecycle.ts
+// src/tools/lifecycle-error.ts
+function getErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/tools/lifecycle-health.ts
+function setHealthStats(state, result) {
+  state.stats.lastHealthCheck = result;
+  state.stats.lastHealthCheckTime = Date.now();
+}
+function isLifecycleStale(state, lifecycleGeneration) {
+  return !state.initialized || state.cleaningUp || state.lifecycleGeneration !== lifecycleGeneration;
+}
+async function runManagedHealthCheck(state, healthCheckFn) {
+  if (!state.initialized || state.cleaningUp) {
+    return {
+      healthy: false,
+      error: "Tool is not initialized"
+    };
+  }
+  if (!healthCheckFn) {
+    return {
+      healthy: true,
+      metadata: { message: "No health check configured" }
+    };
+  }
+  const lifecycleGeneration = state.lifecycleGeneration;
+  try {
+    const result = await healthCheckFn();
+    if (isLifecycleStale(state, lifecycleGeneration)) {
+      return {
+        healthy: false,
+        error: "Tool is not initialized"
+      };
+    }
+    setHealthStats(state, result);
+    return result;
+  } catch (error) {
+    if (isLifecycleStale(state, lifecycleGeneration)) {
+      return {
+        healthy: false,
+        error: "Tool is not initialized"
+      };
+    }
+    const result = {
+      healthy: false,
+      error: getErrorMessage(error)
+    };
+    setHealthStats(state, result);
+    return result;
+  }
+}
+async function runPeriodicManagedHealthCheck(state, healthCheckFn) {
+  if (!healthCheckFn || state.healthCheckInFlight || !state.initialized || state.cleaningUp) {
+    return;
+  }
+  state.healthCheckInFlight = true;
+  const lifecycleGeneration = state.lifecycleGeneration;
+  try {
+    const result = await healthCheckFn();
+    if (!isLifecycleStale(state, lifecycleGeneration)) {
+      setHealthStats(state, result);
+    }
+  } catch (error) {
+    if (!isLifecycleStale(state, lifecycleGeneration)) {
+      setHealthStats(state, {
+        healthy: false,
+        error: getErrorMessage(error)
+      });
+    }
+  } finally {
+    state.healthCheckInFlight = false;
+  }
+}
+
+// src/tools/lifecycle-hooks.ts
+async function performManagedInitialize({
+  ensureBeforeExitHandler,
+  healthCheckFn,
+  healthCheckInterval,
+  initializeFn,
+  runPeriodicHealthCheck,
+  state
+}) {
+  ensureBeforeExitHandler();
+  state.lifecycleGeneration++;
+  if (initializeFn) {
+    await initializeFn();
+  }
+  state.initialized = true;
+  state.stats.initialized = true;
+  if (healthCheckInterval && healthCheckFn) {
+    state.healthCheckTimer = setInterval(() => {
+      void runPeriodicHealthCheck();
+    }, healthCheckInterval);
+  }
+}
+async function performManagedCleanup({
+  cleanupFn,
+  state
+}) {
+  state.cleaningUp = true;
+  if (state.healthCheckTimer) {
+    clearInterval(state.healthCheckTimer);
+    state.healthCheckTimer = void 0;
+  }
+  if (state.beforeExitHandler) {
+    process.off("beforeExit", state.beforeExitHandler);
+    state.beforeExitHandler = void 0;
+  }
+  if (!state.initialized) {
+    state.cleaningUp = false;
+    return;
+  }
+  state.initialized = false;
+  state.stats.initialized = false;
+  if (cleanupFn) {
+    try {
+      await cleanupFn();
+    } finally {
+      state.cleaningUp = false;
+    }
+    return;
+  }
+  state.cleaningUp = false;
+}
+function ensureManagedBeforeExitHandler({
+  autoCleanup,
+  cleanup,
+  logger: logger6,
+  name,
+  state
+}) {
+  if (!autoCleanup || state.beforeExitHandler) {
+    return;
+  }
+  state.beforeExitHandler = () => {
+    cleanup().catch(
+      (err) => logger6.error("Cleanup failed", {
+        toolName: name,
+        error: getErrorMessage(err),
+        ...err instanceof Error && err.stack ? { stack: err.stack } : {}
+      })
+    );
+  };
+  process.on("beforeExit", state.beforeExitHandler);
+}
+
+// src/tools/lifecycle-managed-tool.ts
 var logger3 = createLogger("agentforge:core:tools:lifecycle", { level: "info" /* INFO */ });
 var ManagedTool = class {
   name;
@@ -1493,21 +1641,7 @@ var ManagedTool = class {
   healthCheckFn;
   autoCleanup;
   healthCheckInterval;
-  _initialized = false;
-  _context;
-  _stats = {
-    initialized: false,
-    totalExecutions: 0,
-    successfulExecutions: 0,
-    failedExecutions: 0
-  };
-  _healthCheckTimer;
-  _beforeExitHandler;
-  _healthCheckInFlight = false;
-  _cleaningUp = false;
-  _cleanupPromise;
-  _initializePromise;
-  _lifecycleGeneration = 0;
+  state;
   constructor(config) {
     this.name = config.name;
     this.description = config.description;
@@ -1517,254 +1651,134 @@ var ManagedTool = class {
     this.healthCheckFn = config.healthCheck?.bind(this);
     this.autoCleanup = config.autoCleanup ?? true;
     this.healthCheckInterval = config.healthCheckInterval;
-    this._context = config.context;
+    this.state = {
+      initialized: false,
+      context: config.context,
+      stats: {
+        initialized: false,
+        totalExecutions: 0,
+        successfulExecutions: 0,
+        failedExecutions: 0
+      },
+      healthCheckInFlight: false,
+      cleaningUp: false,
+      lifecycleGeneration: 0
+    };
     this.ensureBeforeExitHandler();
   }
-  /**
-   * Get the tool context (e.g., connection pool, API client)
-   */
   get context() {
-    return this._context;
+    return this.state.context;
   }
-  /**
-   * Set the tool context
-   */
   set context(value) {
-    this._context = value;
+    this.state.context = value;
   }
-  /**
-   * Check if tool is initialized
-   */
   get initialized() {
-    return this._initialized;
+    return this.state.initialized;
   }
-  /**
-   * Initialize the tool
-   */
   async initialize() {
-    if (this._initializePromise) {
-      await this._initializePromise;
+    if (this.state.initializePromise) {
+      await this.state.initializePromise;
       return;
     }
-    if (this._cleanupPromise) {
-      await this._cleanupPromise;
-      if (this._initializePromise) {
-        await this._initializePromise;
+    if (this.state.cleanupPromise) {
+      await this.state.cleanupPromise;
+      if (this.state.initializePromise) {
+        await this.state.initializePromise;
         return;
       }
     }
-    if (this._initialized) {
+    if (this.state.initialized) {
       return;
     }
-    const initializePromise = this.performInitialize();
-    this._initializePromise = initializePromise;
+    const initializePromise = performManagedInitialize({
+      ensureBeforeExitHandler: () => this.ensureBeforeExitHandler(),
+      healthCheckFn: this.healthCheckFn,
+      healthCheckInterval: this.healthCheckInterval,
+      initializeFn: this.initializeFn,
+      runPeriodicHealthCheck: () => this.runPeriodicHealthCheck(),
+      state: this.state
+    });
+    this.state.initializePromise = initializePromise;
     try {
       await initializePromise;
     } finally {
-      this._initializePromise = void 0;
+      this.state.initializePromise = void 0;
     }
   }
-  /**
-   * Execute the tool
-   */
   async execute(input) {
-    if (!this._initialized) {
+    if (!this.state.initialized) {
       throw new Error(`Tool ${this.name} is not initialized. Call initialize() first.`);
     }
     const startTime = Date.now();
-    this._stats.totalExecutions++;
+    this.state.stats.totalExecutions++;
     try {
       const result = await this.executeFn(input);
-      this._stats.successfulExecutions++;
-      this._stats.lastExecutionTime = Date.now() - startTime;
+      this.state.stats.successfulExecutions++;
+      this.state.stats.lastExecutionTime = Date.now() - startTime;
       return result;
     } catch (error) {
-      this._stats.failedExecutions++;
-      this._stats.lastExecutionTime = Date.now() - startTime;
+      this.state.stats.failedExecutions++;
+      this.state.stats.lastExecutionTime = Date.now() - startTime;
       throw error;
     }
   }
-  /**
-   * Cleanup the tool
-   */
   async cleanup() {
-    if (this._cleanupPromise) {
-      await this._cleanupPromise;
+    if (this.state.cleanupPromise) {
+      await this.state.cleanupPromise;
       return;
     }
-    if (this._initializePromise) {
+    if (this.state.initializePromise) {
       try {
-        await this._initializePromise;
+        await this.state.initializePromise;
       } catch {
       }
     }
-    const cleanupPromise = this.performCleanup();
-    this._cleanupPromise = cleanupPromise;
+    const cleanupPromise = performManagedCleanup({
+      cleanupFn: this.cleanupFn,
+      state: this.state
+    });
+    this.state.cleanupPromise = cleanupPromise;
     try {
       await cleanupPromise;
     } finally {
-      this._cleanupPromise = void 0;
-    }
-  }
-  async performCleanup() {
-    this._cleaningUp = true;
-    if (this._healthCheckTimer) {
-      clearInterval(this._healthCheckTimer);
-      this._healthCheckTimer = void 0;
-    }
-    if (this._beforeExitHandler) {
-      process.off("beforeExit", this._beforeExitHandler);
-      this._beforeExitHandler = void 0;
-    }
-    if (!this._initialized) {
-      this._cleaningUp = false;
-      return;
+      this.state.cleanupPromise = void 0;
     }
-    this._initialized = false;
-    this._stats.initialized = false;
-    if (this.cleanupFn) {
-      try {
-        await this.cleanupFn();
-      } finally {
-        this._cleaningUp = false;
-      }
-      return;
-    }
-    this._cleaningUp = false;
   }
-  /**
-   * Run health check
-   */
   async healthCheck() {
-    if (!this._initialized || this._cleaningUp) {
-      return {
-        healthy: false,
-        error: "Tool is not initialized"
-      };
-    }
-    if (!this.healthCheckFn) {
-      return {
-        healthy: true,
-        metadata: { message: "No health check configured" }
-      };
-    }
-    const lifecycleGeneration = this._lifecycleGeneration;
-    try {
-      const result = await this.healthCheckFn();
-      if (!this._initialized || this._cleaningUp || this._lifecycleGeneration !== lifecycleGeneration) {
-        return {
-          healthy: false,
-          error: "Tool is not initialized"
-        };
-      }
-      this._stats.lastHealthCheck = result;
-      this._stats.lastHealthCheckTime = Date.now();
-      return result;
-    } catch (error) {
-      if (!this._initialized || this._cleaningUp || this._lifecycleGeneration !== lifecycleGeneration) {
-        return {
-          healthy: false,
-          error: "Tool is not initialized"
-        };
-      }
-      const result = {
-        healthy: false,
-        error: getErrorMessage(error)
-      };
-      this._stats.lastHealthCheck = result;
-      this._stats.lastHealthCheckTime = Date.now();
-      return result;
-    }
+    return runManagedHealthCheck(this.state, this.healthCheckFn);
   }
-  /**
-   * Get tool statistics
-   */
   getStats() {
-    return { ...this._stats };
+    return { ...this.state.stats };
   }
-  /**
-   * Reset statistics
-   */
   resetStats() {
-    this._stats.totalExecutions = 0;
-    this._stats.successfulExecutions = 0;
-    this._stats.failedExecutions = 0;
-    this._stats.lastExecutionTime = void 0;
+    this.state.stats.totalExecutions = 0;
+    this.state.stats.successfulExecutions = 0;
+    this.state.stats.failedExecutions = 0;
+    this.state.stats.lastExecutionTime = void 0;
   }
-  /**
-   * Convert to LangChain tool format
-   */
   toLangChainTool() {
     return {
       name: this.name,
       description: this.description,
-      invoke: async (input) => {
-        return await this.execute(input);
-      }
+      invoke: async (input) => this.execute(input)
     };
   }
   async runPeriodicHealthCheck() {
-    if (!this.healthCheckFn || this._healthCheckInFlight || !this._initialized || this._cleaningUp) {
-      return;
-    }
-    this._healthCheckInFlight = true;
-    const lifecycleGeneration = this._lifecycleGeneration;
-    try {
-      const result = await this.healthCheckFn();
-      if (!this._initialized || this._cleaningUp || this._lifecycleGeneration !== lifecycleGeneration) {
-        return;
-      }
-      this._stats.lastHealthCheck = result;
-      this._stats.lastHealthCheckTime = Date.now();
-    } catch (error) {
-      if (!this._initialized || this._cleaningUp || this._lifecycleGeneration !== lifecycleGeneration) {
-        return;
-      }
-      this._stats.lastHealthCheck = {
-        healthy: false,
-        error: getErrorMessage(error)
-      };
-      this._stats.lastHealthCheckTime = Date.now();
-    } finally {
-      this._healthCheckInFlight = false;
-    }
-  }
-  async performInitialize() {
-    this.ensureBeforeExitHandler();
-    this._lifecycleGeneration++;
-    if (this.initializeFn) {
-      await this.initializeFn();
-    }
-    this._initialized = true;
-    this._stats.initialized = true;
-    if (this.healthCheckInterval && this.healthCheckFn) {
-      this._healthCheckTimer = setInterval(() => {
-        void this.runPeriodicHealthCheck();
-      }, this.healthCheckInterval);
-    }
+    await runPeriodicManagedHealthCheck(this.state, this.healthCheckFn);
   }
   ensureBeforeExitHandler() {
-    if (!this.autoCleanup || this._beforeExitHandler) {
-      return;
-    }
-    this._beforeExitHandler = () => {
-      this.cleanup().catch(
-        (err) => logger3.error("Cleanup failed", {
-          toolName: this.name,
-          error: getErrorMessage(err),
-          ...err instanceof Error && err.stack ? { stack: err.stack } : {}
-        })
-      );
-    };
-    process.on("beforeExit", this._beforeExitHandler);
+    ensureManagedBeforeExitHandler({
+      autoCleanup: this.autoCleanup,
+      cleanup: () => this.cleanup(),
+      logger: logger3,
+      name: this.name,
+      state: this.state
+    });
   }
 };
 function createManagedTool(config) {
   return new ManagedTool(config);
 }
-function getErrorMessage(error) {
-  return error instanceof Error ? error.message : String(error);
-}
 
 // src/tools/composition.ts
 function isConditionalStep(step) {

package/dist/index.d.cts

@@ -1077,11 +1077,6 @@ interface JsonObject {
     [key: string]: JsonValue;
 }
 
-/**
- * Tool Lifecycle Management - Manage tool initialization, cleanup, and resources
- * @module tools/lifecycle
- */
-
 interface ToolHealthCheckResult {
     healthy: boolean;
     error?: string;
@@ -1109,9 +1104,7 @@ interface ManagedToolStats {
     lastHealthCheck?: ToolHealthCheckResult;
     lastHealthCheckTime?: number;
 }
-/**
- * Managed tool with lifecycle hooks
- */
+
 declare class ManagedTool<TContext = undefined, TInput = unknown, TOutput = unknown> {
     readonly name: string;
     readonly description: string;
@@ -1121,69 +1114,25 @@ declare class ManagedTool<TContext = undefined, TInput = unknown, TOutput = unkn
     private readonly healthCheckFn?;
     private readonly autoCleanup;
     private readonly healthCheckInterval?;
-    private _initialized;
-    private _context;
-    private _stats;
-    private _healthCheckTimer?;
-    private _beforeExitHandler?;
-    private _healthCheckInFlight;
-    private _cleaningUp;
-    private _cleanupPromise?;
-    private _initializePromise?;
-    private _lifecycleGeneration;
+    private readonly state;
     constructor(config: ManagedToolConfig<TContext, TInput, TOutput>);
-    /**
-     * Get the tool context (e.g., connection pool, API client)
-     */
     get context(): TContext | undefined;
-    /**
-     * Set the tool context
-     */
     set context(value: TContext | undefined);
-    /**
-     * Check if tool is initialized
-     */
     get initialized(): boolean;
-    /**
-     * Initialize the tool
-     */
     initialize(): Promise<void>;
-    /**
-     * Execute the tool
-     */
     execute(input: TInput): Promise<TOutput>;
-    /**
-     * Cleanup the tool
-     */
     cleanup(): Promise<void>;
-    private performCleanup;
-    /**
-     * Run health check
-     */
     healthCheck(): Promise<ToolHealthCheckResult>;
-    /**
-     * Get tool statistics
-     */
     getStats(): ManagedToolStats;
-    /**
-     * Reset statistics
-     */
     resetStats(): void;
-    /**
-     * Convert to LangChain tool format
-     */
     toLangChainTool(): {
         name: string;
         description: string;
         invoke: (input: TInput) => Promise<TOutput>;
     };
     private runPeriodicHealthCheck;
-    private performInitialize;
     private ensureBeforeExitHandler;
 }
-/**
- * Create a managed tool
- */
 declare function createManagedTool<TContext = undefined, TInput = unknown, TOutput = unknown>(config: ManagedToolConfig<TContext, TInput, TOutput>): ManagedTool<TContext, TInput, TOutput>;
 
 /**

package/dist/index.d.ts

@@ -1077,11 +1077,6 @@ interface JsonObject {
     [key: string]: JsonValue;
 }
 
-/**
- * Tool Lifecycle Management - Manage tool initialization, cleanup, and resources
- * @module tools/lifecycle
- */
-
 interface ToolHealthCheckResult {
     healthy: boolean;
     error?: string;
@@ -1109,9 +1104,7 @@ interface ManagedToolStats {
     lastHealthCheck?: ToolHealthCheckResult;
     lastHealthCheckTime?: number;
 }
-/**
- * Managed tool with lifecycle hooks
- */
+
 declare class ManagedTool<TContext = undefined, TInput = unknown, TOutput = unknown> {
     readonly name: string;
     readonly description: string;
@@ -1121,69 +1114,25 @@ declare class ManagedTool<TContext = undefined, TInput = unknown, TOutput = unkn
     private readonly healthCheckFn?;
     private readonly autoCleanup;
     private readonly healthCheckInterval?;
-    private _initialized;
-    private _context;
-    private _stats;
-    private _healthCheckTimer?;
-    private _beforeExitHandler?;
-    private _healthCheckInFlight;
-    private _cleaningUp;
-    private _cleanupPromise?;
-    private _initializePromise?;
-    private _lifecycleGeneration;
+    private readonly state;
     constructor(config: ManagedToolConfig<TContext, TInput, TOutput>);
-    /**
-     * Get the tool context (e.g., connection pool, API client)
-     */
     get context(): TContext | undefined;
-    /**
-     * Set the tool context
-     */
     set context(value: TContext | undefined);
-    /**
-     * Check if tool is initialized
-     */
     get initialized(): boolean;
-    /**
-     * Initialize the tool
-     */
     initialize(): Promise<void>;
-    /**
-     * Execute the tool
-     */
     execute(input: TInput): Promise<TOutput>;
-    /**
-     * Cleanup the tool
-     */
     cleanup(): Promise<void>;
-    private performCleanup;
-    /**
-     * Run health check
-     */
     healthCheck(): Promise<ToolHealthCheckResult>;
-    /**
-     * Get tool statistics
-     */
     getStats(): ManagedToolStats;
-    /**
-     * Reset statistics
-     */
     resetStats(): void;
-    /**
-     * Convert to LangChain tool format
-     */
     toLangChainTool(): {
         name: string;
         description: string;
         invoke: (input: TInput) => Promise<TOutput>;
     };
     private runPeriodicHealthCheck;
-    private performInitialize;
     private ensureBeforeExitHandler;
 }
-/**
- * Create a managed tool
- */
 declare function createManagedTool<TContext = undefined, TInput = unknown, TOutput = unknown>(config: ManagedToolConfig<TContext, TInput, TOutput>): ManagedTool<TContext, TInput, TOutput>;
 
 /**

package/dist/index.js

@@ -1307,7 +1307,155 @@ function createToolExecutor(config = {}) {
   };
 }
 
-// src/tools/lifecycle.ts
+// src/tools/lifecycle-error.ts
+function getErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/tools/lifecycle-health.ts
+function setHealthStats(state, result) {
+  state.stats.lastHealthCheck = result;
+  state.stats.lastHealthCheckTime = Date.now();
+}
+function isLifecycleStale(state, lifecycleGeneration) {
+  return !state.initialized || state.cleaningUp || state.lifecycleGeneration !== lifecycleGeneration;
+}
+async function runManagedHealthCheck(state, healthCheckFn) {
+  if (!state.initialized || state.cleaningUp) {
+    return {
+      healthy: false,
+      error: "Tool is not initialized"
+    };
+  }
+  if (!healthCheckFn) {
+    return {
+      healthy: true,
+      metadata: { message: "No health check configured" }
+    };
+  }
+  const lifecycleGeneration = state.lifecycleGeneration;
+  try {
+    const result = await healthCheckFn();
+    if (isLifecycleStale(state, lifecycleGeneration)) {
+      return {
+        healthy: false,
+        error: "Tool is not initialized"
+      };
+    }
+    setHealthStats(state, result);
+    return result;
+  } catch (error) {
+    if (isLifecycleStale(state, lifecycleGeneration)) {
+      return {
+        healthy: false,
+        error: "Tool is not initialized"
+      };
+    }
+    const result = {
+      healthy: false,
+      error: getErrorMessage(error)
+    };
+    setHealthStats(state, result);
+    return result;
+  }
+}
+async function runPeriodicManagedHealthCheck(state, healthCheckFn) {
+  if (!healthCheckFn || state.healthCheckInFlight || !state.initialized || state.cleaningUp) {
+    return;
+  }
+  state.healthCheckInFlight = true;
+  const lifecycleGeneration = state.lifecycleGeneration;
+  try {
+    const result = await healthCheckFn();
+    if (!isLifecycleStale(state, lifecycleGeneration)) {
+      setHealthStats(state, result);
+    }
+  } catch (error) {
+    if (!isLifecycleStale(state, lifecycleGeneration)) {
+      setHealthStats(state, {
+        healthy: false,
+        error: getErrorMessage(error)
+      });
+    }
+  } finally {
+    state.healthCheckInFlight = false;
+  }
+}
+
+// src/tools/lifecycle-hooks.ts
+async function performManagedInitialize({
+  ensureBeforeExitHandler,
+  healthCheckFn,
+  healthCheckInterval,
+  initializeFn,
+  runPeriodicHealthCheck,
+  state
+}) {
+  ensureBeforeExitHandler();
+  state.lifecycleGeneration++;
+  if (initializeFn) {
+    await initializeFn();
+  }
+  state.initialized = true;
+  state.stats.initialized = true;
+  if (healthCheckInterval && healthCheckFn) {
+    state.healthCheckTimer = setInterval(() => {
+      void runPeriodicHealthCheck();
+    }, healthCheckInterval);
+  }
+}
+async function performManagedCleanup({
+  cleanupFn,
+  state
+}) {
+  state.cleaningUp = true;
+  if (state.healthCheckTimer) {
+    clearInterval(state.healthCheckTimer);
+    state.healthCheckTimer = void 0;
+  }
+  if (state.beforeExitHandler) {
+    process.off("beforeExit", state.beforeExitHandler);
+    state.beforeExitHandler = void 0;
+  }
+  if (!state.initialized) {
+    state.cleaningUp = false;
+    return;
+  }
+  state.initialized = false;
+  state.stats.initialized = false;
+  if (cleanupFn) {
+    try {
+      await cleanupFn();
+    } finally {
+      state.cleaningUp = false;
+    }
+    return;
+  }
+  state.cleaningUp = false;
+}
+function ensureManagedBeforeExitHandler({
+  autoCleanup,
+  cleanup,
+  logger: logger6,
+  name,
+  state
+}) {
+  if (!autoCleanup || state.beforeExitHandler) {
+    return;
+  }
+  state.beforeExitHandler = () => {
+    cleanup().catch(
+      (err) => logger6.error("Cleanup failed", {
+        toolName: name,
+        error: getErrorMessage(err),
+        ...err instanceof Error && err.stack ? { stack: err.stack } : {}
+      })
+    );
+  };
+  process.on("beforeExit", state.beforeExitHandler);
+}
+
+// src/tools/lifecycle-managed-tool.ts
 var logger3 = createLogger("agentforge:core:tools:lifecycle", { level: "info" /* INFO */ });
 var ManagedTool = class {
   name;
@@ -1318,21 +1466,7 @@ var ManagedTool = class {
   healthCheckFn;
   autoCleanup;
   healthCheckInterval;
-  _initialized = false;
-  _context;
-  _stats = {
-    initialized: false,
-    totalExecutions: 0,
-    successfulExecutions: 0,
-    failedExecutions: 0
-  };
-  _healthCheckTimer;
-  _beforeExitHandler;
-  _healthCheckInFlight = false;
-  _cleaningUp = false;
-  _cleanupPromise;
-  _initializePromise;
-  _lifecycleGeneration = 0;
+  state;
   constructor(config) {
     this.name = config.name;
     this.description = config.description;
@@ -1342,254 +1476,134 @@ var ManagedTool = class {
     this.healthCheckFn = config.healthCheck?.bind(this);
     this.autoCleanup = config.autoCleanup ?? true;
     this.healthCheckInterval = config.healthCheckInterval;
-    this._context = config.context;
+    this.state = {
+      initialized: false,
+      context: config.context,
+      stats: {
+        initialized: false,
+        totalExecutions: 0,
+        successfulExecutions: 0,
+        failedExecutions: 0
+      },
+      healthCheckInFlight: false,
+      cleaningUp: false,
+      lifecycleGeneration: 0
+    };
     this.ensureBeforeExitHandler();
   }
-  /**
-   * Get the tool context (e.g., connection pool, API client)
-   */
   get context() {
-    return this._context;
+    return this.state.context;
   }
-  /**
-   * Set the tool context
-   */
   set context(value) {
-    this._context = value;
+    this.state.context = value;
   }
-  /**
-   * Check if tool is initialized
-   */
   get initialized() {
-    return this._initialized;
+    return this.state.initialized;
   }
-  /**
-   * Initialize the tool
-   */
   async initialize() {
-    if (this._initializePromise) {
-      await this._initializePromise;
+    if (this.state.initializePromise) {
+      await this.state.initializePromise;
       return;
     }
-    if (this._cleanupPromise) {
-      await this._cleanupPromise;
-      if (this._initializePromise) {
-        await this._initializePromise;
+    if (this.state.cleanupPromise) {
+      await this.state.cleanupPromise;
+      if (this.state.initializePromise) {
+        await this.state.initializePromise;
         return;
       }
     }
-    if (this._initialized) {
+    if (this.state.initialized) {
       return;
     }
-    const initializePromise = this.performInitialize();
-    this._initializePromise = initializePromise;
+    const initializePromise = performManagedInitialize({
+      ensureBeforeExitHandler: () => this.ensureBeforeExitHandler(),
+      healthCheckFn: this.healthCheckFn,
+      healthCheckInterval: this.healthCheckInterval,
+      initializeFn: this.initializeFn,
+      runPeriodicHealthCheck: () => this.runPeriodicHealthCheck(),
+      state: this.state
+    });
+    this.state.initializePromise = initializePromise;
     try {
       await initializePromise;
     } finally {
-      this._initializePromise = void 0;
+      this.state.initializePromise = void 0;
     }
   }
-  /**
-   * Execute the tool
-   */
   async execute(input) {
-    if (!this._initialized) {
+    if (!this.state.initialized) {
       throw new Error(`Tool ${this.name} is not initialized. Call initialize() first.`);
     }
     const startTime = Date.now();
-    this._stats.totalExecutions++;
+    this.state.stats.totalExecutions++;
     try {
       const result = await this.executeFn(input);
-      this._stats.successfulExecutions++;
-      this._stats.lastExecutionTime = Date.now() - startTime;
+      this.state.stats.successfulExecutions++;
+      this.state.stats.lastExecutionTime = Date.now() - startTime;
       return result;
     } catch (error) {
-      this._stats.failedExecutions++;
-      this._stats.lastExecutionTime = Date.now() - startTime;
+      this.state.stats.failedExecutions++;
+      this.state.stats.lastExecutionTime = Date.now() - startTime;
       throw error;
     }
   }
-  /**
-   * Cleanup the tool
-   */
   async cleanup() {
-    if (this._cleanupPromise) {
-      await this._cleanupPromise;
+    if (this.state.cleanupPromise) {
+      await this.state.cleanupPromise;
       return;
     }
-    if (this._initializePromise) {
+    if (this.state.initializePromise) {
       try {
-        await this._initializePromise;
+        await this.state.initializePromise;
       } catch {
       }
     }
-    const cleanupPromise = this.performCleanup();
-    this._cleanupPromise = cleanupPromise;
+    const cleanupPromise = performManagedCleanup({
+      cleanupFn: this.cleanupFn,
+      state: this.state
+    });
+    this.state.cleanupPromise = cleanupPromise;
     try {
       await cleanupPromise;
     } finally {
-      this._cleanupPromise = void 0;
-    }
-  }
-  async performCleanup() {
-    this._cleaningUp = true;
-    if (this._healthCheckTimer) {
-      clearInterval(this._healthCheckTimer);
-      this._healthCheckTimer = void 0;
-    }
-    if (this._beforeExitHandler) {
-      process.off("beforeExit", this._beforeExitHandler);
-      this._beforeExitHandler = void 0;
-    }
-    if (!this._initialized) {
-      this._cleaningUp = false;
-      return;
+      this.state.cleanupPromise = void 0;
     }
-    this._initialized = false;
-    this._stats.initialized = false;
-    if (this.cleanupFn) {
-      try {
-        await this.cleanupFn();
-      } finally {
-        this._cleaningUp = false;
-      }
-      return;
-    }
-    this._cleaningUp = false;
   }
-  /**
-   * Run health check
-   */
   async healthCheck() {
-    if (!this._initialized || this._cleaningUp) {
-      return {
-        healthy: false,
-        error: "Tool is not initialized"
-      };
-    }
-    if (!this.healthCheckFn) {
-      return {
-        healthy: true,
-        metadata: { message: "No health check configured" }
-      };
-    }
-    const lifecycleGeneration = this._lifecycleGeneration;
-    try {
-      const result = await this.healthCheckFn();
-      if (!this._initialized || this._cleaningUp || this._lifecycleGeneration !== lifecycleGeneration) {
-        return {
-          healthy: false,
-          error: "Tool is not initialized"
-        };
-      }
-      this._stats.lastHealthCheck = result;
-      this._stats.lastHealthCheckTime = Date.now();
-      return result;
-    } catch (error) {
-      if (!this._initialized || this._cleaningUp || this._lifecycleGeneration !== lifecycleGeneration) {
-        return {
-          healthy: false,
-          error: "Tool is not initialized"
-        };
-      }
-      const result = {
-        healthy: false,
-        error: getErrorMessage(error)
-      };
-      this._stats.lastHealthCheck = result;
-      this._stats.lastHealthCheckTime = Date.now();
-      return result;
-    }
+    return runManagedHealthCheck(this.state, this.healthCheckFn);
   }
-  /**
-   * Get tool statistics
-   */
   getStats() {
-    return { ...this._stats };
+    return { ...this.state.stats };
   }
-  /**
-   * Reset statistics
-   */
   resetStats() {
-    this._stats.totalExecutions = 0;
-    this._stats.successfulExecutions = 0;
-    this._stats.failedExecutions = 0;
-    this._stats.lastExecutionTime = void 0;
+    this.state.stats.totalExecutions = 0;
+    this.state.stats.successfulExecutions = 0;
+    this.state.stats.failedExecutions = 0;
+    this.state.stats.lastExecutionTime = void 0;
   }
-  /**
-   * Convert to LangChain tool format
-   */
   toLangChainTool() {
     return {
       name: this.name,
       description: this.description,
-      invoke: async (input) => {
-        return await this.execute(input);
-      }
+      invoke: async (input) => this.execute(input)
     };
   }
   async runPeriodicHealthCheck() {
-    if (!this.healthCheckFn || this._healthCheckInFlight || !this._initialized || this._cleaningUp) {
-      return;
-    }
-    this._healthCheckInFlight = true;
-    const lifecycleGeneration = this._lifecycleGeneration;
-    try {
-      const result = await this.healthCheckFn();
-      if (!this._initialized || this._cleaningUp || this._lifecycleGeneration !== lifecycleGeneration) {
-        return;
-      }
-      this._stats.lastHealthCheck = result;
-      this._stats.lastHealthCheckTime = Date.now();
-    } catch (error) {
-      if (!this._initialized || this._cleaningUp || this._lifecycleGeneration !== lifecycleGeneration) {
-        return;
-      }
-      this._stats.lastHealthCheck = {
-        healthy: false,
-        error: getErrorMessage(error)
-      };
-      this._stats.lastHealthCheckTime = Date.now();
-    } finally {
-      this._healthCheckInFlight = false;
-    }
-  }
-  async performInitialize() {
-    this.ensureBeforeExitHandler();
-    this._lifecycleGeneration++;
-    if (this.initializeFn) {
-      await this.initializeFn();
-    }
-    this._initialized = true;
-    this._stats.initialized = true;
-    if (this.healthCheckInterval && this.healthCheckFn) {
-      this._healthCheckTimer = setInterval(() => {
-        void this.runPeriodicHealthCheck();
-      }, this.healthCheckInterval);
-    }
+    await runPeriodicManagedHealthCheck(this.state, this.healthCheckFn);
   }
   ensureBeforeExitHandler() {
-    if (!this.autoCleanup || this._beforeExitHandler) {
-      return;
-    }
-    this._beforeExitHandler = () => {
-      this.cleanup().catch(
-        (err) => logger3.error("Cleanup failed", {
-          toolName: this.name,
-          error: getErrorMessage(err),
-          ...err instanceof Error && err.stack ? { stack: err.stack } : {}
-        })
-      );
-    };
-    process.on("beforeExit", this._beforeExitHandler);
+    ensureManagedBeforeExitHandler({
+      autoCleanup: this.autoCleanup,
+      cleanup: () => this.cleanup(),
+      logger: logger3,
+      name: this.name,
+      state: this.state
+    });
   }
 };
 function createManagedTool(config) {
   return new ManagedTool(config);
 }
-function getErrorMessage(error) {
-  return error instanceof Error ? error.message : String(error);
-}
 
 // src/tools/composition.ts
 function isConditionalStep(step) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentforge/core",
-  "version": "0.16.43",
+  "version": "0.16.45",
   "description": "Production-ready TypeScript agent framework built on LangGraph with orchestration, middleware, and typed abstractions.",
   "type": "module",
   "main": "./dist/index.cjs",