agent-swarm-kit 1.1.181 → 1.1.182

package/build/index.cjs

@@ -442,7 +442,7 @@ async function writeFileAtomic(file, data, options = {}) {
     }
 }
 
-var _a$4, _b$2, _c$1, _d$1, _e;
+var _a$4, _b$1, _c, _d;
 /** @private Symbol for memoizing the wait-for-initialization operation in PersistBase*/
 const BASE_WAIT_FOR_INIT_SYMBOL = Symbol("wait-for-init");
 /** @private Symbol for creating a new key in a persistent list*/
@@ -549,7 +549,7 @@ const BASE_UNLINK_RETRY_DELAY = 1000;
  * Attempts to remove a file if invalid JSON is detected during initialization.
  * Retries the operation multiple times with delays to handle transient errors, ensuring robust setup.
  * @private
-*/
+ */
 const BASE_WAIT_FOR_INIT_UNLINK_FN = async (filePath) => functoolsKit.trycatch(functoolsKit.retry(async () => {
     try {
         await fs.unlink(filePath);
@@ -567,7 +567,7 @@ const BASE_WAIT_FOR_INIT_UNLINK_FN = async (filePath) => functoolsKit.trycatch(f
  * Ensures the persistence layer is robust by cleaning up corrupted files during setup (e.g., for swarm or session data).
  * @private
  * @throws {Error} If directory creation or file validation fails (e.g., permissions or I/O errors).
-*/
+ */
 const BASE_WAIT_FOR_INIT_FN = async (self) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
         swarm$1.loggerService.debug(BASE_WAIT_FOR_INIT_FN_METHOD_NAME, {
@@ -593,7 +593,7 @@ const BASE_WAIT_FOR_INIT_FN = async (self) => {
  * Initializes the last count by scanning existing keys if not already set, used in `PersistList` for ordered storage.
  * @private
  * @throws {Error} If key generation fails due to underlying storage issues (e.g., directory access).
-*/
+ */
 const LIST_CREATE_KEY_FN = async (self) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
         swarm$1.loggerService.debug(LIST_CREATE_KEY_FN_METHOD_NAME, {
@@ -618,7 +618,7 @@ const LIST_CREATE_KEY_FN = async (self) => {
  * Uses the last key to fetch and delete the item atomically, ensuring consistency in list operations.
  * @private
  * @throws {Error} If reading or removing the item fails (e.g., file not found or permissions).
-*/
+ */
 const LIST_POP_FN = async (self) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
         swarm$1.loggerService.debug(LIST_POP_FN_METHOD_NAME, {
@@ -648,7 +648,7 @@ const LIST_POP_FN = async (self) => {
  * Determines the highest numeric key value for ordered list management (e.g., dequeuing events).
  * @private
  * @throws {Error} If key retrieval fails due to underlying storage issues (e.g., directory access).
-*/
+ */
 const LIST_GET_LAST_KEY_FN = async (self) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
         swarm$1.loggerService.debug(LIST_GET_LAST_KEY_FN_METHOD_NAME, {
@@ -671,12 +671,12 @@ const LIST_GET_LAST_KEY_FN = async (self) => {
  * Provides foundational methods for reading, writing, and managing entities as JSON files, supporting swarm utilities like `PersistAliveUtils`.
  * @template EntityName - The type of entity name (e.g., `SwarmName`, `SessionId`), defaults to `string`, used as a subdirectory.
  * @implements {IPersistBase}
-*/
-const PersistBase = functoolsKit.makeExtendable(class {
+ */
+class PersistBase {
     /**
      * Creates a new `PersistBase` instance for managing persistent storage of entities.
      * Sets up the storage directory based on the entity name (e.g., `SwarmName` for swarm-specific data) and base directory.
-    */
+     */
     constructor(entityName, baseDir = path.join(process.cwd(), "logs/data")) {
         this.entityName = entityName;
         this.baseDir = baseDir;
@@ -684,7 +684,7 @@ const PersistBase = functoolsKit.makeExtendable(class {
          * Memoized initialization function ensuring it runs only once per instance.
          * Uses `singleshot` to prevent redundant initialization calls, critical for swarm setup efficiency.
          * @private
-        */
+         */
         this[_a$4] = functoolsKit.singleshot(async () => await BASE_WAIT_FOR_INIT_FN(this));
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
             swarm$1.loggerService.debug(PERSIST_BASE_METHOD_NAME_CTOR, {
@@ -696,7 +696,7 @@ const PersistBase = functoolsKit.makeExtendable(class {
     /**
      * Computes the full file path for an entity based on its ID.
      * @private
-    */
+     */
     _getFilePath(entityId) {
         return path.join(this.baseDir, this.entityName, `${entityId}.json`);
     }
@@ -704,7 +704,7 @@ const PersistBase = functoolsKit.makeExtendable(class {
      * Initializes the storage directory, creating it if it doesn’t exist, and validates existing entities.
      * Removes invalid JSON files during initialization to ensure data integrity (e.g., for `SwarmName`-based alive status).
      * @throws {Error} If directory creation or entity validation fails (e.g., permissions or I/O errors).
-    */
+     */
     async waitForInit(initial) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
             swarm$1.loggerService.debug(PERSIST_BASE_METHOD_NAME_WAIT_FOR_INIT, {
@@ -717,7 +717,7 @@ const PersistBase = functoolsKit.makeExtendable(class {
      * Retrieves the number of entities stored in the directory.
      * Counts only files with a `.json` extension, useful for monitoring storage usage (e.g., active sessions).
      * @throws {Error} If reading the directory fails (e.g., permissions or directory not found).
-    */
+     */
     async getCount() {
         const files = await fs.readdir(this._directory);
         const { length } = files.filter((file) => file.endsWith(".json"));
@@ -728,7 +728,7 @@ const PersistBase = functoolsKit.makeExtendable(class {
      * Core method for retrieving persisted data (e.g., alive status for a `SessionId` in a `SwarmName` context).
      * @template T - The specific type of the entity (e.g., `IPersistAliveData`), defaults to `IEntity`.
      * @throws {Error} If the file is not found (`ENOENT`) or parsing fails (e.g., invalid JSON).
-    */
+     */
     async readValue(entityId) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
             swarm$1.loggerService.debug(PERSIST_BASE_METHOD_NAME_READ_VALUE, {
@@ -751,7 +751,7 @@ const PersistBase = functoolsKit.makeExtendable(class {
      * Checks if an entity exists in storage by its ID.
      * Efficiently verifies presence without reading the full entity (e.g., checking if a `SessionId` has memory).
      * @throws {Error} If checking existence fails for reasons other than the file not existing.
-    */
+     */
     async hasValue(entityId) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
             swarm$1.loggerService.debug(PERSIST_BASE_METHOD_NAME_HAS_VALUE, {
@@ -775,7 +775,7 @@ const PersistBase = functoolsKit.makeExtendable(class {
      * Uses atomic file writing via `writeFileAtomic` to ensure data integrity (e.g., persisting `AgentName` for a `SwarmName`).
      * @template T - The specific type of the entity (e.g., `IPersistActiveAgentData`), defaults to `IEntity`.
      * @throws {Error} If writing to the file system fails (e.g., permissions or disk space).
-    */
+     */
     async writeValue(entityId, entity) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
             swarm$1.loggerService.debug(PERSIST_BASE_METHOD_NAME_WRITE_VALUE, {
@@ -795,7 +795,7 @@ const PersistBase = functoolsKit.makeExtendable(class {
      * Removes an entity from storage by its ID.
      * Deletes the corresponding JSON file, used for cleanup (e.g., removing a `SessionId`’s memory).
      * @throws {Error} If the entity is not found (`ENOENT`) or deletion fails (e.g., permissions).
-    */
+     */
     async removeValue(entityId) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
             swarm$1.loggerService.debug(PERSIST_BASE_METHOD_NAME_REMOVE_VALUE, {
@@ -817,7 +817,7 @@ const PersistBase = functoolsKit.makeExtendable(class {
      * Removes all entities from storage under this entity name.
      * Deletes all `.json` files in the directory, useful for resetting persistence (e.g., clearing a `SwarmName`’s data).
      * @throws {Error} If reading the directory or deleting files fails (e.g., permissions).
-    */
+     */
     async removeAll() {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
             swarm$1.loggerService.debug(PERSIST_BASE_METHOD_NAME_REMOVE_ALL, {
@@ -839,7 +839,7 @@ const PersistBase = functoolsKit.makeExtendable(class {
      * Yields entities in ascending order, useful for batch processing (e.g., listing all `SessionId`s in a `SwarmName`).
      * @template T - The specific type of the entities (e.g., `IPersistAliveData`), defaults to `IEntity`.
      * @throws {Error} If reading the directory or entity files fails (e.g., permissions or invalid JSON).
-    */
+     */
     async *values() {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
             swarm$1.loggerService.debug(PERSIST_BASE_METHOD_NAME_VALUES, {
@@ -867,7 +867,7 @@ const PersistBase = functoolsKit.makeExtendable(class {
      * Iterates over all entity IDs in storage, sorted numerically.
      * Yields IDs in ascending order, useful for key enumeration (e.g., listing `SessionId`s in a `SwarmName`).
      * @throws {Error} If reading the directory fails (e.g., permissions or directory not found).
-    */
+     */
     async *keys() {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
             swarm$1.loggerService.debug(PERSIST_BASE_METHOD_NAME_KEYS, {
@@ -893,7 +893,7 @@ const PersistBase = functoolsKit.makeExtendable(class {
     /**
      * Implements the async iterator protocol for iterating over entities.
      * Delegates to the `values` method for iteration, enabling `for await` loops over entities.
-    */
+     */
     async *[(_a$4 = BASE_WAIT_FOR_INIT_SYMBOL, Symbol.asyncIterator)]() {
         for await (const entity of this.values()) {
             yield entity;
@@ -904,7 +904,7 @@ const PersistBase = functoolsKit.makeExtendable(class {
      * Useful for selective retrieval (e.g., finding online `SessionId`s in a `SwarmName`).
      * @template T - The specific type of the entities (e.g., `IPersistAliveData`), defaults to `IEntity`.
      * @throws {Error} If reading entities fails during iteration (e.g., invalid JSON).
-    */
+     */
     async *filter(predicate) {
         for await (const entity of this.values()) {
             if (predicate(entity)) {
@@ -917,7 +917,7 @@ const PersistBase = functoolsKit.makeExtendable(class {
      * Stops yielding after reaching the specified total, useful for pagination (e.g., sampling `SessionId`s).
      * @template T - The specific type of the entities (e.g., `IPersistStateData`), defaults to `IEntity`.
      * @throws {Error} If reading entities fails during iteration (e.g., permissions).
-    */
+     */
     async *take(total, predicate) {
         let count = 0;
         if (predicate) {
@@ -942,86 +942,87 @@ const PersistBase = functoolsKit.makeExtendable(class {
             }
         }
     }
-});
+}
+// @ts-ignore
+PersistBase = functoolsKit.makeExtendable(PersistBase);
 /**
  * Extends `PersistBase` to provide a persistent list structure with push/pop operations.
  * Manages entities with numeric keys for ordered access, suitable for queues or logs in the swarm system.
  * @template EntityName - The type of entity name (e.g., `SwarmName`), defaults to `string`, used as a subdirectory.
  * @extends {PersistBase<EntityName>}
-*/
-const PersistList = functoolsKit.makeExtendable((_e = class extends PersistBase {
+ */
+class PersistList extends PersistBase {
+    /**
+     * Creates a new `PersistList` instance for managing a persistent list of entities.
+     * Inherits directory setup from `PersistBase` and adds list-specific functionality (e.g., for `SwarmName`-based event logs).
+     */
+    constructor(entityName, baseDir) {
+        super(entityName, baseDir);
+        /** @private Tracks the last used numeric key for the list, initialized to `null` until computed*/
+        this._lastCount = null;
         /**
-         * Creates a new `PersistList` instance for managing a persistent list of entities.
-         * Inherits directory setup from `PersistBase` and adds list-specific functionality (e.g., for `SwarmName`-based event logs).
-        */
-        constructor(entityName, baseDir) {
-            super(entityName, baseDir);
-            /** @private Tracks the last used numeric key for the list, initialized to `null` until computed*/
-            this._lastCount = null;
-            /**
-             * Queued function to create a new unique key for a list item.
-             * Ensures sequential key generation under concurrent calls using `queued` decorator.
-             * @private
-             * @throws {Error} If key generation fails due to underlying storage issues.
-            */
-            this[_b$2] = functoolsKit.queued(async () => await LIST_CREATE_KEY_FN(this));
-            /**
-             * Retrieves the key of the last item in the list.
-             * Scans all keys to find the highest numeric value, used for pop operations (e.g., dequeuing from a `SwarmName` log).
-             * @private
-             * @throws {Error} If key retrieval fails due to underlying storage issues.
-            */
-            this[_c$1] = async () => await LIST_GET_LAST_KEY_FN(this);
-            /**
-             * Queued function to remove and return the last item in the list.
-             * Ensures atomic pop operations under concurrent calls using `queued` decorator.
-             * @private
-             * @template T - The specific type of the entity (e.g., `IPersistStateData`), defaults to `IEntity`.
-             * @throws {Error} If reading or removing the item fails.
-            */
-            this[_d$1] = functoolsKit.queued(async () => await LIST_POP_FN(this));
-            GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
-                swarm$1.loggerService.debug(PERSIST_LIST_METHOD_NAME_CTOR, {
-                    entityName: this.entityName,
-                    baseDir,
-                });
-        }
+         * Queued function to create a new unique key for a list item.
+         * Ensures sequential key generation under concurrent calls using `queued` decorator.
+         * @private
+         * @throws {Error} If key generation fails due to underlying storage issues.
+         */
+        this[_b$1] = functoolsKit.queued(async () => await LIST_CREATE_KEY_FN(this));
         /**
-         * Adds an entity to the end of the persistent list with a new unique numeric key.
-         * Useful for appending items like messages or events in swarm operations (e.g., within a `SwarmName`).
-         * @template T - The specific type of the entity (e.g., `IPersistStateData`), defaults to `IEntity`.
-         * @throws {Error} If writing to the file system fails (e.g., permissions or disk space).
-        */
-        async push(entity) {
-            GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
-                swarm$1.loggerService.debug(PERSIST_LIST_METHOD_NAME_PUSH, {
-                    entityName: this.entityName,
-                });
-            return await this.writeValue(await this[LIST_CREATE_KEY_SYMBOL](), entity);
-        }
+         * Retrieves the key of the last item in the list.
+         * Scans all keys to find the highest numeric value, used for pop operations (e.g., dequeuing from a `SwarmName` log).
+         * @private
+         * @throws {Error} If key retrieval fails due to underlying storage issues.
+         */
+        this[_c] = async () => await LIST_GET_LAST_KEY_FN(this);
         /**
-         * Removes and returns the last entity from the persistent list.
-         * Useful for dequeuing items or retrieving recent entries (e.g., latest event in a `SwarmName` log).
+         * Queued function to remove and return the last item in the list.
+         * Ensures atomic pop operations under concurrent calls using `queued` decorator.
+         * @private
          * @template T - The specific type of the entity (e.g., `IPersistStateData`), defaults to `IEntity`.
-         * @throws {Error} If reading or removing the entity fails (e.g., file not found).
-        */
-        async pop() {
-            GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
-                swarm$1.loggerService.debug(PERSIST_LIST_METHOD_NAME_POP, {
-                    entityName: this.entityName,
-                });
-            return await this[LIST_POP_SYMBOL]();
-        }
-    },
-    _b$2 = LIST_CREATE_KEY_SYMBOL,
-    _c$1 = LIST_GET_LAST_KEY_SYMBOL,
-    _d$1 = LIST_POP_SYMBOL,
-    _e));
+         * @throws {Error} If reading or removing the item fails.
+         */
+        this[_d] = functoolsKit.queued(async () => await LIST_POP_FN(this));
+        GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
+            swarm$1.loggerService.debug(PERSIST_LIST_METHOD_NAME_CTOR, {
+                entityName: this.entityName,
+                baseDir,
+            });
+    }
+    /**
+     * Adds an entity to the end of the persistent list with a new unique numeric key.
+     * Useful for appending items like messages or events in swarm operations (e.g., within a `SwarmName`).
+     * @template T - The specific type of the entity (e.g., `IPersistStateData`), defaults to `IEntity`.
+     * @throws {Error} If writing to the file system fails (e.g., permissions or disk space).
+     */
+    async push(entity) {
+        GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
+            swarm$1.loggerService.debug(PERSIST_LIST_METHOD_NAME_PUSH, {
+                entityName: this.entityName,
+            });
+        return await this.writeValue(await this[LIST_CREATE_KEY_SYMBOL](), entity);
+    }
+    /**
+     * Removes and returns the last entity from the persistent list.
+     * Useful for dequeuing items or retrieving recent entries (e.g., latest event in a `SwarmName` log).
+     * @template T - The specific type of the entity (e.g., `IPersistStateData`), defaults to `IEntity`.
+     * @throws {Error} If reading or removing the entity fails (e.g., file not found).
+     */
+    async pop() {
+        GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
+            swarm$1.loggerService.debug(PERSIST_LIST_METHOD_NAME_POP, {
+                entityName: this.entityName,
+            });
+        return await this[LIST_POP_SYMBOL]();
+    }
+}
+_b$1 = LIST_CREATE_KEY_SYMBOL, _c = LIST_GET_LAST_KEY_SYMBOL, _d = LIST_POP_SYMBOL;
+// @ts-ignore
+PersistList = functoolsKit.makeExtendable(PersistList);
 /**
  * Utility class for managing swarm-related persistence, including active agents and navigation stacks.
  * Provides methods to get/set active agents and navigation stacks per client (`SessionId`) and swarm (`SwarmName`), with customizable adapters.
  * @implements {IPersistSwarmControl}
-*/
+ */
 class PersistSwarmUtils {
     constructor() {
         /** @private Default constructor for active agent persistence, defaults to `PersistBase`*/
@@ -1141,18 +1142,18 @@ class PersistSwarmUtils {
 }
 /**
  * Singleton instance of `PersistSwarmUtils` for managing swarm persistence globally.
-*/
+ */
 const PersistSwarmAdapter = new PersistSwarmUtils();
 /**
  * Exported singleton for swarm persistence operations, cast as the control interface.
  * Provides a global point of access for managing active agents and navigation stacks tied to `SwarmName`.
-*/
+ */
 const PersistSwarm = PersistSwarmAdapter;
 /**
  * Utility class for managing state persistence per client (`SessionId`) and state name (`StateName`) in the swarm system.
  * Provides methods to get/set state data with a customizable persistence adapter.
  * @implements {IPersistStateControl}
-*/
+ */
 class PersistStateUtils {
     constructor() {
         /** @private Default constructor for state persistence, defaults to `PersistBase`*/
@@ -1217,18 +1218,18 @@ class PersistStateUtils {
 }
 /**
  * Singleton instance of `PersistStateUtils` for managing state persistence globally.
-*/
+ */
 const PersistStateAdapter = new PersistStateUtils();
 /**
  * Exported singleton for state persistence operations, cast as the control interface.
  * Provides a global point of access for managing state persistence tied to `StateName` and `SessionId`.
-*/
+ */
 const PersistState = PersistStateAdapter;
 /**
  * Utility class for managing storage persistence per client (`SessionId`) and storage name (`StorageName`) in the swarm system.
  * Provides methods to get/set storage data with a customizable persistence adapter.
  * @implements {IPersistStorageControl}
-*/
+ */
 class PersistStorageUtils {
     constructor() {
         /** @private Default constructor for storage persistence, defaults to `PersistBase`*/
@@ -1293,18 +1294,18 @@ class PersistStorageUtils {
 }
 /**
  * Singleton instance of `PersistStorageUtils` for managing storage persistence globally.
-*/
+ */
 const PersistStorageAdapter = new PersistStorageUtils();
 /**
  * Exported singleton for storage persistence operations, cast as the control interface.
  * Provides a global point of access for managing storage persistence tied to `StorageName` and `SessionId`.
-*/
+ */
 const PersistStorage = PersistStorageAdapter;
 /**
  * Utility class for managing memory persistence per client (`SessionId`) in the swarm system.
  * Provides methods to get/set memory data with a customizable persistence adapter.
  * @implements {IPersistMemoryControl}
-*/
+ */
 class PersistMemoryUtils {
     constructor() {
         /** @private Default constructor for memory persistence, defaults to `PersistBase`*/
@@ -1378,18 +1379,18 @@ class PersistMemoryUtils {
 }
 /**
  * Singleton instance of `PersistMemoryUtils` for managing memory persistence globally.
-*/
+ */
 const PersistMemoryAdapter = new PersistMemoryUtils();
 /**
  * Exported singleton for memory persistence operations, cast as the control interface.
  * Provides a global point of access for managing memory persistence tied to `SessionId`.
-*/
+ */
 const PersistMemory = PersistMemoryAdapter;
 /**
  * Utility class for managing alive status persistence per client (`SessionId`) in the swarm system.
  * Provides methods to mark clients as online/offline and check their status within a `SwarmName`, with a customizable adapter.
  * @implements {IPersistAliveControl}
-*/
+ */
 class PersistAliveUtils {
     constructor() {
         /** @private Default constructor for alive status persistence, defaults to `PersistBase`*/
@@ -1475,18 +1476,18 @@ class PersistAliveUtils {
 }
 /**
  * Singleton instance of `PersistAliveUtils` for managing alive status persistence globally.
-*/
+ */
 const PersistAliveAdapter = new PersistAliveUtils();
 /**
  * Exported singleton for alive status persistence operations, cast as the control interface.
  * Provides a global point of access for managing client online/offline status in the swarm.
-*/
+ */
 const PersistAlive = PersistAliveAdapter;
 /**
  * Utility class for managing policy data persistence in the swarm system.
  * Provides methods to get and set banned clients within a `SwarmName`, with a customizable adapter.
  * @implements {IPersistPolicyControl}
-*/
+ */
 class PersistPolicyUtils {
     constructor() {
         /** @private Default constructor for policy data persistence, defaults to `PersistBase`*/
@@ -1543,18 +1544,18 @@ class PersistPolicyUtils {
 }
 /**
  * Singleton instance of `PersistPolicyUtils` for managing policy data persistence globally.
-*/
+ */
 const PersistPolicyAdapter = new PersistPolicyUtils();
 /**
  * Exported singleton for policy persistence operations, cast as the control interface.
  * Provides a global point of access for managing client bans in the swarm.
-*/
+ */
 const PersistPolicy = PersistPolicyAdapter;
 /**
  * Utility class for managing embedding data persistence in the swarm system.
  * Provides methods to read and write embedding vectors with a customizable adapter.
  * @implements {IPersistEmbeddingControl}
-*/
+ */
 class PersistEmbeddingUtils {
     constructor() {
         /** @private Default constructor for embedding data persistence, defaults to `PersistBase`*/
@@ -1611,15 +1612,15 @@ class PersistEmbeddingUtils {
 }
 /**
  * Singleton instance of `PersistEmbeddingUtils` for managing embedding data persistence globally.
-*/
+ */
 const PersistEmbeddingAdapter = new PersistEmbeddingUtils();
 /**
  * Exported singleton for embedding persistence operations, cast as the control interface.
  * Provides a global point of access for managing embedding cache in the system.
-*/
+ */
 const PersistEmbedding = PersistEmbeddingAdapter;
 
-var _a$3, _b$1, _c, _d;
+var _a$3, _b;
 /** @private Symbol for memoizing the waitForInit method in HistoryMemoryInstance*/
 const HISTORY_MEMORY_INSTANCE_WAIT_FOR_INIT = Symbol("wait-for-init");
 /** @private Symbol for memoizing the waitForInit method in HistoryPersistInstance*/
@@ -1667,7 +1668,7 @@ const METHOD_NAME_DISPOSE = "HistoryUtils.dispose";
 /**
  * Initializes the memory-based history instance by loading initial data.
  * @private
-*/
+ */
 const HISTORY_MEMORY_INSTANCE_WAIT_FOR_INIT_FN = async (agentName, self) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
         swarm$1.loggerService.debug(HISTORY_MEMORY_INSTANCE_METHOD_NAME_WAIT_FOR_INIT, {
@@ -1681,7 +1682,7 @@ const HISTORY_MEMORY_INSTANCE_WAIT_FOR_INIT_FN = async (agentName, self) => {
 /**
  * Initializes the persistent history instance by loading data from storage.
  * @private
-*/
+ */
 const HISTORY_PERSIST_INSTANCE_WAIT_FOR_INIT_FN = async (agentName, self) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
         swarm$1.loggerService.debug(HISTORY_PERSIST_INSTANCE_METHOD_NAME_WAIT_FOR_INIT, {
@@ -1696,73 +1697,52 @@ const HISTORY_PERSIST_INSTANCE_WAIT_FOR_INIT_FN = async (agentName, self) => {
 /**
  * Manages a persistent history of messages, storing them in memory and on disk.
  * @implements {IHistoryInstance}
-*/
-const HistoryPersistInstance = functoolsKit.makeExtendable((_b$1 = class {
+ */
+class HistoryPersistInstance {
+    /**
+     * Initializes the history for an agent, loading data from persistent storage if needed.
+     */
+    async waitForInit(agentName) {
+        return await this[HISTORY_PERSIST_INSTANCE_WAIT_FOR_INIT](agentName);
+    }
+    /**
+     * Creates a new persistent history instance.
+     * Invokes onInit and onRef callbacks if provided.
+     */
+    constructor(clientId, callbacks) {
+        this.clientId = clientId;
+        this.callbacks = callbacks;
+        /** @private The in-memory array of history messages*/
+        this._array = [];
         /**
-         * Initializes the history for an agent, loading data from persistent storage if needed.
-        */
-        async waitForInit(agentName) {
-            return await this[HISTORY_PERSIST_INSTANCE_WAIT_FOR_INIT](agentName);
+         * Memoized initialization function to ensure it runs only once per agent.
+         * @private
+         */
+        this[_a$3] = functoolsKit.singleshot(async (agentName) => await HISTORY_PERSIST_INSTANCE_WAIT_FOR_INIT_FN(agentName, this));
+        GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
+            swarm$1.loggerService.debug(HISTORY_PERSIST_INSTANCE_METHOD_NAME_CTOR, {
+                clientId: this.clientId,
+            });
+        this._persistStorage = new PersistList(this.clientId, `./logs/data/history`);
+        if (callbacks.onInit) {
+            callbacks.onInit(clientId);
         }
-        /**
-         * Creates a new persistent history instance.
-         * Invokes onInit and onRef callbacks if provided.
-        */
-        constructor(clientId, callbacks) {
-            this.clientId = clientId;
-            this.callbacks = callbacks;
-            /** @private The in-memory array of history messages*/
-            this._array = [];
-            /**
-             * Memoized initialization function to ensure it runs only once per agent.
-             * @private
-            */
-            this[_a$3] = functoolsKit.singleshot(async (agentName) => await HISTORY_PERSIST_INSTANCE_WAIT_FOR_INIT_FN(agentName, this));
-            GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
-                swarm$1.loggerService.debug(HISTORY_PERSIST_INSTANCE_METHOD_NAME_CTOR, {
-                    clientId: this.clientId,
-                });
-            this._persistStorage = new PersistList(this.clientId, `./logs/data/history`);
-            if (callbacks.onInit) {
-                callbacks.onInit(clientId);
-            }
-            if (callbacks.onRef) {
-                callbacks.onRef(this);
-            }
-            if (callbacks.filterCondition) {
-                this.iterate = async function* (agentName) {
-                    GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
-                        swarm$1.loggerService.debug(HISTORY_PERSIST_INSTANCE_METHOD_NAME_ITERATE_CONDITION, {
-                            clientId: this.clientId,
-                            agentName,
-                        });
-                    if (this.callbacks.onRead) {
-                        this.callbacks.onReadBegin &&
-                            this.callbacks.onReadBegin(this.clientId, agentName);
-                        for (const item of this._array) {
-                            if (await this.callbacks.filterCondition(item, this.clientId, agentName)) {
-                                this.callbacks.onRead(item, this.clientId, agentName);
-                                yield item;
-                            }
-                        }
-                        if (this.callbacks.getSystemPrompt) {
-                            for (const content of await this.callbacks.getSystemPrompt(this.clientId, agentName)) {
-                                yield {
-                                    role: "system",
-                                    content,
-                                    agentName,
-                                    mode: "tool",
-                                };
-                            }
-                        }
-                        this.callbacks.onReadEnd &&
-                            this.callbacks.onReadEnd(this.clientId, agentName);
-                        return;
-                    }
+        if (callbacks.onRef) {
+            callbacks.onRef(this);
+        }
+        if (callbacks.filterCondition) {
+            this.iterate = async function* (agentName) {
+                GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
+                    swarm$1.loggerService.debug(HISTORY_PERSIST_INSTANCE_METHOD_NAME_ITERATE_CONDITION, {
+                        clientId: this.clientId,
+                        agentName,
+                    });
+                if (this.callbacks.onRead) {
                     this.callbacks.onReadBegin &&
                         this.callbacks.onReadBegin(this.clientId, agentName);
                     for (const item of this._array) {
                         if (await this.callbacks.filterCondition(item, this.clientId, agentName)) {
+                            this.callbacks.onRead(item, this.clientId, agentName);
                             yield item;
                         }
                     }
@@ -1778,171 +1758,172 @@ const HistoryPersistInstance = functoolsKit.makeExtendable((_b$1 = class {
                     }
                     this.callbacks.onReadEnd &&
                         this.callbacks.onReadEnd(this.clientId, agentName);
-                };
-            }
-        }
-        /**
-         * Iterates over history messages, applying filters and system prompts if configured.
-         * Invokes onRead callbacks during iteration if provided.
-        */
-        async *iterate(agentName) {
-            GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
-                swarm$1.loggerService.debug(HISTORY_PERSIST_INSTANCE_METHOD_NAME_ITERATE, {
-                    clientId: this.clientId,
-                    agentName,
-                });
-            if (this.callbacks.onRead) {
+                    return;
+                }
                 this.callbacks.onReadBegin &&
                     this.callbacks.onReadBegin(this.clientId, agentName);
                 for (const item of this._array) {
-                    this.callbacks.onRead(item, this.clientId, agentName);
-                    yield item;
+                    if (await this.callbacks.filterCondition(item, this.clientId, agentName)) {
+                        yield item;
+                    }
+                }
+                if (this.callbacks.getSystemPrompt) {
+                    for (const content of await this.callbacks.getSystemPrompt(this.clientId, agentName)) {
+                        yield {
+                            role: "system",
+                            content,
+                            agentName,
+                            mode: "tool",
+                        };
+                    }
                 }
                 this.callbacks.onReadEnd &&
                     this.callbacks.onReadEnd(this.clientId, agentName);
-                return;
-            }
+            };
+        }
+    }
+    /**
+     * Iterates over history messages, applying filters and system prompts if configured.
+     * Invokes onRead callbacks during iteration if provided.
+     */
+    async *iterate(agentName) {
+        GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
+            swarm$1.loggerService.debug(HISTORY_PERSIST_INSTANCE_METHOD_NAME_ITERATE, {
+                clientId: this.clientId,
+                agentName,
+            });
+        if (this.callbacks.onRead) {
             this.callbacks.onReadBegin &&
                 this.callbacks.onReadBegin(this.clientId, agentName);
             for (const item of this._array) {
+                this.callbacks.onRead(item, this.clientId, agentName);
                 yield item;
             }
-            if (this.callbacks.getSystemPrompt) {
-                for (const content of await this.callbacks.getSystemPrompt(this.clientId, agentName)) {
-                    yield {
-                        role: "system",
-                        content,
-                        agentName,
-                        mode: "tool",
-                    };
-                }
-            }
             this.callbacks.onReadEnd &&
                 this.callbacks.onReadEnd(this.clientId, agentName);
+            return;
         }
-        /**
-         * Adds a new message to the history, persisting it to storage.
-         * Invokes onPush and onChange callbacks if provided.
-        */
-        async push(value, agentName) {
-            GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
-                swarm$1.loggerService.debug(HISTORY_PERSIST_INSTANCE_METHOD_NAME_PUSH, {
-                    clientId: this.clientId,
-                    agentName,
-                });
-            this.callbacks.onPush &&
-                this.callbacks.onPush(value, this.clientId, agentName);
-            this._array.push(value);
-            this.callbacks.onChange &&
-                this.callbacks.onChange(this._array, this.clientId, agentName);
-            await this._persistStorage.push(value);
-        }
-        /**
-         * Removes and returns the last message from the history, updating persistent storage.
-         * Invokes onPop and onChange callbacks if provided.
-        */
-        async pop(agentName) {
-            GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
-                swarm$1.loggerService.debug(HISTORY_PERSIST_INSTANCE_METHOD_NAME_POP, {
-                    clientId: this.clientId,
-                    agentName,
-                });
-            const value = this._array.pop() ?? null;
-            this.callbacks.onPop &&
-                this.callbacks.onPop(value, this.clientId, agentName);
-            this.callbacks.onChange &&
-                this.callbacks.onChange(this._array, this.clientId, agentName);
-            await this._persistStorage.pop();
-            return value;
+        this.callbacks.onReadBegin &&
+            this.callbacks.onReadBegin(this.clientId, agentName);
+        for (const item of this._array) {
+            yield item;
         }
-        /**
-         * Disposes of the history, clearing all data if agentName is null.
-         * Invokes onDispose callback if provided.
-        */
-        async dispose(agentName) {
-            GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
-                swarm$1.loggerService.debug(HISTORY_PERSIST_INSTANCE_METHOD_NAME_DISPOSE, {
-                    clientId: this.clientId,
+        if (this.callbacks.getSystemPrompt) {
+            for (const content of await this.callbacks.getSystemPrompt(this.clientId, agentName)) {
+                yield {
+                    role: "system",
+                    content,
                     agentName,
-                });
-            if (agentName === null) {
-                this.callbacks.onDispose && this.callbacks.onDispose(this.clientId);
-                this._array = [];
+                    mode: "tool",
+                };
             }
-            return;
         }
-    },
-    _a$3 = HISTORY_PERSIST_INSTANCE_WAIT_FOR_INIT,
-    _b$1));
+        this.callbacks.onReadEnd &&
+            this.callbacks.onReadEnd(this.clientId, agentName);
+    }
+    /**
+     * Adds a new message to the history, persisting it to storage.
+     * Invokes onPush and onChange callbacks if provided.
+     */
+    async push(value, agentName) {
+        GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
+            swarm$1.loggerService.debug(HISTORY_PERSIST_INSTANCE_METHOD_NAME_PUSH, {
+                clientId: this.clientId,
+                agentName,
+            });
+        this.callbacks.onPush &&
+            this.callbacks.onPush(value, this.clientId, agentName);
+        this._array.push(value);
+        this.callbacks.onChange &&
+            this.callbacks.onChange(this._array, this.clientId, agentName);
+        await this._persistStorage.push(value);
+    }
+    /**
+     * Removes and returns the last message from the history, updating persistent storage.
+     * Invokes onPop and onChange callbacks if provided.
+     */
+    async pop(agentName) {
+        GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
+            swarm$1.loggerService.debug(HISTORY_PERSIST_INSTANCE_METHOD_NAME_POP, {
+                clientId: this.clientId,
+                agentName,
+            });
+        const value = this._array.pop() ?? null;
+        this.callbacks.onPop &&
+            this.callbacks.onPop(value, this.clientId, agentName);
+        this.callbacks.onChange &&
+            this.callbacks.onChange(this._array, this.clientId, agentName);
+        await this._persistStorage.pop();
+        return value;
+    }
+    /**
+     * Disposes of the history, clearing all data if agentName is null.
+     * Invokes onDispose callback if provided.
+     */
+    async dispose(agentName) {
+        GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
+            swarm$1.loggerService.debug(HISTORY_PERSIST_INSTANCE_METHOD_NAME_DISPOSE, {
+                clientId: this.clientId,
+                agentName,
+            });
+        if (agentName === null) {
+            this.callbacks.onDispose && this.callbacks.onDispose(this.clientId);
+            this._array = [];
+        }
+        return;
+    }
+}
+_a$3 = HISTORY_PERSIST_INSTANCE_WAIT_FOR_INIT;
+// @ts-ignore
+HistoryPersistInstance = functoolsKit.makeExtendable(HistoryPersistInstance);
 /**
  * Manages an in-memory history of messages without persistence.
  * @implements {IHistoryInstance}
-*/
-const HistoryMemoryInstance = functoolsKit.makeExtendable((_d = class {
+ */
+class HistoryMemoryInstance {
+    /**
+     * Initializes the history for an agent, loading initial data if needed.
+     */
+    async waitForInit(agentName) {
+        return await this[HISTORY_MEMORY_INSTANCE_WAIT_FOR_INIT](agentName);
+    }
+    /**
+     * Creates a new in-memory history instance.
+     * Invokes onInit and onRef callbacks if provided.
+     */
+    constructor(clientId, callbacks) {
+        this.clientId = clientId;
+        this.callbacks = callbacks;
+        /** @private The in-memory array of history messages*/
+        this._array = [];
         /**
-         * Initializes the history for an agent, loading initial data if needed.
-        */
-        async waitForInit(agentName) {
-            return await this[HISTORY_MEMORY_INSTANCE_WAIT_FOR_INIT](agentName);
+         * Memoized initialization function to ensure it runs only once per agent.
+         * @private
+         */
+        this[_b] = functoolsKit.singleshot(async (agentName) => await HISTORY_MEMORY_INSTANCE_WAIT_FOR_INIT_FN(agentName, this));
+        GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
+            swarm$1.loggerService.debug(HISTORY_MEMORY_INSTANCE_METHOD_NAME_CTOR, {
+                clientId: this.clientId,
+            });
+        if (callbacks.onInit) {
+            callbacks.onInit(clientId);
         }
-        /**
-         * Creates a new in-memory history instance.
-         * Invokes onInit and onRef callbacks if provided.
-        */
-        constructor(clientId, callbacks) {
-            this.clientId = clientId;
-            this.callbacks = callbacks;
-            /** @private The in-memory array of history messages*/
-            this._array = [];
-            /**
-             * Memoized initialization function to ensure it runs only once per agent.
-             * @private
-            */
-            this[_c] = functoolsKit.singleshot(async (agentName) => await HISTORY_MEMORY_INSTANCE_WAIT_FOR_INIT_FN(agentName, this));
-            GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
-                swarm$1.loggerService.debug(HISTORY_MEMORY_INSTANCE_METHOD_NAME_CTOR, {
-                    clientId: this.clientId,
-                });
-            if (callbacks.onInit) {
-                callbacks.onInit(clientId);
-            }
-            if (callbacks.onRef) {
-                callbacks.onRef(this);
-            }
-            if (callbacks.filterCondition) {
-                this.iterate = async function* (agentName) {
-                    GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
-                        swarm$1.loggerService.debug(HISTORY_MEMORY_INSTANCE_METHOD_NAME_ITERATE_CONDITION, {
-                            clientId: this.clientId,
-                            agentName,
-                        });
-                    if (this.callbacks.onRead) {
-                        this.callbacks.onReadBegin &&
-                            this.callbacks.onReadBegin(this.clientId, agentName);
-                        for (const item of this._array) {
-                            if (await this.callbacks.filterCondition(item, this.clientId, agentName)) {
-                                this.callbacks.onRead(item, this.clientId, agentName);
-                                yield item;
-                            }
-                        }
-                        if (this.callbacks.getSystemPrompt) {
-                            for (const content of await this.callbacks.getSystemPrompt(this.clientId, agentName)) {
-                                yield {
-                                    role: "system",
-                                    content,
-                                    agentName,
-                                    mode: "tool",
-                                };
-                            }
-                        }
-                        this.callbacks.onReadEnd &&
-                            this.callbacks.onReadEnd(this.clientId, agentName);
-                        return;
-                    }
+        if (callbacks.onRef) {
+            callbacks.onRef(this);
+        }
+        if (callbacks.filterCondition) {
+            this.iterate = async function* (agentName) {
+                GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
+                    swarm$1.loggerService.debug(HISTORY_MEMORY_INSTANCE_METHOD_NAME_ITERATE_CONDITION, {
+                        clientId: this.clientId,
+                        agentName,
+                    });
+                if (this.callbacks.onRead) {
                     this.callbacks.onReadBegin &&
                         this.callbacks.onReadBegin(this.clientId, agentName);
                     for (const item of this._array) {
                         if (await this.callbacks.filterCondition(item, this.clientId, agentName)) {
+                            this.callbacks.onRead(item, this.clientId, agentName);
                             yield item;
                         }
                     }
@@ -1958,106 +1939,128 @@ const HistoryMemoryInstance = functoolsKit.makeExtendable((_d = class {
                     }
                     this.callbacks.onReadEnd &&
                         this.callbacks.onReadEnd(this.clientId, agentName);
-                };
-            }
-        }
-        /**
-         * Iterates over history messages, applying filters and system prompts if configured.
-         * Invokes onRead callbacks during iteration if provided.
-        */
-        async *iterate(agentName) {
-            GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
-                swarm$1.loggerService.debug(HISTORY_MEMORY_INSTANCE_METHOD_NAME_ITERATE, {
-                    clientId: this.clientId,
-                    agentName,
-                });
-            if (this.callbacks.onRead) {
+                    return;
+                }
                 this.callbacks.onReadBegin &&
                     this.callbacks.onReadBegin(this.clientId, agentName);
                 for (const item of this._array) {
-                    this.callbacks.onRead(item, this.clientId, agentName);
-                    yield item;
+                    if (await this.callbacks.filterCondition(item, this.clientId, agentName)) {
+                        yield item;
+                    }
+                }
+                if (this.callbacks.getSystemPrompt) {
+                    for (const content of await this.callbacks.getSystemPrompt(this.clientId, agentName)) {
+                        yield {
+                            role: "system",
+                            content,
+                            agentName,
+                            mode: "tool",
+                        };
+                    }
                 }
                 this.callbacks.onReadEnd &&
                     this.callbacks.onReadEnd(this.clientId, agentName);
-                return;
-            }
+            };
+        }
+    }
+    /**
+     * Iterates over history messages, applying filters and system prompts if configured.
+     * Invokes onRead callbacks during iteration if provided.
+     */
+    async *iterate(agentName) {
+        GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
+            swarm$1.loggerService.debug(HISTORY_MEMORY_INSTANCE_METHOD_NAME_ITERATE, {
+                clientId: this.clientId,
+                agentName,
+            });
+        if (this.callbacks.onRead) {
             this.callbacks.onReadBegin &&
                 this.callbacks.onReadBegin(this.clientId, agentName);
             for (const item of this._array) {
+                this.callbacks.onRead(item, this.clientId, agentName);
                 yield item;
             }
-            if (this.callbacks.getSystemPrompt) {
-                for (const content of await this.callbacks.getSystemPrompt(this.clientId, agentName)) {
-                    yield {
-                        role: "system",
-                        content,
-                        agentName,
-                        mode: "tool",
-                    };
-                }
-            }
             this.callbacks.onReadEnd &&
                 this.callbacks.onReadEnd(this.clientId, agentName);
+            return;
         }
-        /**
-         * Adds a new message to the in-memory history.
-         * Invokes onPush and onChange callbacks if provided.
-        */
-        async push(value, agentName) {
-            GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
-                swarm$1.loggerService.debug(HISTORY_MEMORY_INSTANCE_METHOD_NAME_PUSH, {
-                    clientId: this.clientId,
-                    agentName,
-                });
-            this.callbacks.onPush &&
-                this.callbacks.onPush(value, this.clientId, agentName);
-            this._array.push(value);
-            this.callbacks.onChange &&
-                this.callbacks.onChange(this._array, this.clientId, agentName);
-            return Promise.resolve();
-        }
-        /**
-         * Removes and returns the last message from the in-memory history.
-         * Invokes onPop and onChange callbacks if provided.
-        */
-        async pop(agentName) {
-            GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
-                swarm$1.loggerService.debug(HISTORY_MEMORY_INSTANCE_METHOD_NAME_POP, {
-                    clientId: this.clientId,
-                    agentName,
-                });
-            const value = this._array.pop() ?? null;
-            this.callbacks.onPop &&
-                this.callbacks.onPop(value, this.clientId, agentName);
-            this.callbacks.onChange &&
-                this.callbacks.onChange(this._array, this.clientId, agentName);
-            return Promise.resolve(value);
+        this.callbacks.onReadBegin &&
+            this.callbacks.onReadBegin(this.clientId, agentName);
+        for (const item of this._array) {
+            yield item;
         }
-        /**
-         * Disposes of the history, clearing all data if agentName is null.
-         * Invokes onDispose callback if provided.
-        */
-        async dispose(agentName) {
-            GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
-                swarm$1.loggerService.debug(HISTORY_MEMORY_INSTANCE_METHOD_NAME_DISPOSE, {
-                    clientId: this.clientId,
+        if (this.callbacks.getSystemPrompt) {
+            for (const content of await this.callbacks.getSystemPrompt(this.clientId, agentName)) {
+                yield {
+                    role: "system",
+                    content,
                     agentName,
-                });
-            if (agentName === null) {
-                this.callbacks.onDispose && this.callbacks.onDispose(this.clientId);
-                this._array = [];
+                    mode: "tool",
+                };
             }
-            return Promise.resolve();
         }
-    },
-    _c = HISTORY_MEMORY_INSTANCE_WAIT_FOR_INIT,
-    _d));
+        this.callbacks.onReadEnd &&
+            this.callbacks.onReadEnd(this.clientId, agentName);
+    }
+    /**
+     * Adds a new message to the in-memory history.
+     * Invokes onPush and onChange callbacks if provided.
+     */
+    async push(value, agentName) {
+        GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
+            swarm$1.loggerService.debug(HISTORY_MEMORY_INSTANCE_METHOD_NAME_PUSH, {
+                clientId: this.clientId,
+                agentName,
+            });
+        this.callbacks.onPush &&
+            this.callbacks.onPush(value, this.clientId, agentName);
+        this._array.push(value);
+        this.callbacks.onChange &&
+            this.callbacks.onChange(this._array, this.clientId, agentName);
+        return Promise.resolve();
+    }
+    /**
+     * Removes and returns the last message from the in-memory history.
+     * Invokes onPop and onChange callbacks if provided.
+     */
+    async pop(agentName) {
+        GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
+            swarm$1.loggerService.debug(HISTORY_MEMORY_INSTANCE_METHOD_NAME_POP, {
+                clientId: this.clientId,
+                agentName,
+            });
+        const value = this._array.pop() ?? null;
+        this.callbacks.onPop &&
+            this.callbacks.onPop(value, this.clientId, agentName);
+        this.callbacks.onChange &&
+            this.callbacks.onChange(this._array, this.clientId, agentName);
+        return Promise.resolve(value);
+    }
+    /**
+     * Disposes of the history, clearing all data if agentName is null.
+     * Invokes onDispose callback if provided.
+     */
+    async dispose(agentName) {
+        GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
+            swarm$1.loggerService.debug(HISTORY_MEMORY_INSTANCE_METHOD_NAME_DISPOSE, {
+                clientId: this.clientId,
+                agentName,
+            });
+        if (agentName === null) {
+            this.callbacks.onDispose && this.callbacks.onDispose(this.clientId);
+            this._array = [];
+        }
+        return Promise.resolve();
+    }
+}
+_b = HISTORY_MEMORY_INSTANCE_WAIT_FOR_INIT;
+// @ts-ignore
+HistoryMemoryInstance = functoolsKit.makeExtendable(HistoryMemoryInstance);
 /**
  * Provides utilities for managing history instances, supporting both memory and persistent storage.
  * @implements {IHistoryAdapter}
  * @implements {IHistoryControl}
-*/
+ */
 class HistoryUtils {
     constructor() {
         /** @private The configured lifecycle callbacks for history instances*/
@@ -2168,11 +2171,11 @@ class HistoryUtils {
 }
 /**
  * Singleton instance of HistoryUtils implementing the history adapter interface.
-*/
+ */
 const HistoryAdapter = new HistoryUtils();
 /**
  * Exported History Control interface for configuring history behavior.
-*/
+ */
 const History = HistoryAdapter;
 
 /**
@@ -2268,14 +2271,14 @@ const beginContext = (run) => (...args) => {
     return fn();
 };
 
-var _a$2, _b;
+var _a$2;
 /** @private Symbol for memoizing the waitForInit method in LoggerInstance*/
 const LOGGER_INSTANCE_WAIT_FOR_INIT = Symbol("wait-for-init");
 /**
  * Initializes the logger instance by invoking the onInit callback if provided.
  * Ensures initialization runs asynchronously and is executed only once via singleshot.
  * @private
-*/
+ */
 const LOGGER_INSTANCE_WAIT_FOR_FN = async (self) => {
     if (self.callbacks.onInit) {
         self.callbacks.onInit(self.clientId);
@@ -2286,73 +2289,74 @@ const LOGGER_INSTANCE_WAIT_FOR_FN = async (self) => {
  * Implements ILoggerInstance for client-specific logging with lifecycle management.
  * Integrates with GLOBAL_CONFIG for console logging control and callbacks for custom behavior.
  * @implements {ILoggerInstance}
-*/
-const LoggerInstance = functoolsKit.makeExtendable((_b = class {
-        /**
-         * Creates a new logger instance for a specific client.
-        */
-        constructor(clientId, callbacks) {
-            this.clientId = clientId;
-            this.callbacks = callbacks;
-            /**
-             * Memoized initialization function to ensure it runs only once using singleshot.
-             * Invokes LOGGER_INSTANCE_WAIT_FOR_FN to handle onInit callback execution.
-             * @private
-            */
-            this[_a$2] = functoolsKit.singleshot(async () => await LOGGER_INSTANCE_WAIT_FOR_FN(this));
-        }
-        /**
-         * Initializes the logger instance, invoking the onInit callback if provided.
-         * Ensures initialization is performed only once, memoized via singleshot.
-        */
-        async waitForInit() {
-            return await this[LOGGER_INSTANCE_WAIT_FOR_INIT]();
-        }
+ */
+class LoggerInstance {
+    /**
+     * Creates a new logger instance for a specific client.
+     */
+    constructor(clientId, callbacks) {
+        this.clientId = clientId;
+        this.callbacks = callbacks;
         /**
-         * Logs a message to the console (if enabled) and invokes the onLog callback if provided.
-         * Controlled by GLOBAL_CONFIG.CC_LOGGER_ENABLE_CONSOLE for console output.
-        */
-        log(topic, ...args) {
-            GLOBAL_CONFIG.CC_LOGGER_ENABLE_CONSOLE &&
-                console.log(`[clientId=${this.clientId}]`, topic, ...args);
-            if (this.callbacks.onLog) {
-                this.callbacks.onLog(this.clientId, topic, ...args);
-            }
+         * Memoized initialization function to ensure it runs only once using singleshot.
+         * Invokes LOGGER_INSTANCE_WAIT_FOR_FN to handle onInit callback execution.
+         * @private
+         */
+        this[_a$2] = functoolsKit.singleshot(async () => await LOGGER_INSTANCE_WAIT_FOR_FN(this));
+    }
+    /**
+     * Initializes the logger instance, invoking the onInit callback if provided.
+     * Ensures initialization is performed only once, memoized via singleshot.
+     */
+    async waitForInit() {
+        return await this[LOGGER_INSTANCE_WAIT_FOR_INIT]();
+    }
+    /**
+     * Logs a message to the console (if enabled) and invokes the onLog callback if provided.
+     * Controlled by GLOBAL_CONFIG.CC_LOGGER_ENABLE_CONSOLE for console output.
+     */
+    log(topic, ...args) {
+        GLOBAL_CONFIG.CC_LOGGER_ENABLE_CONSOLE &&
+            console.log(`[clientId=${this.clientId}]`, topic, ...args);
+        if (this.callbacks.onLog) {
+            this.callbacks.onLog(this.clientId, topic, ...args);
         }
-        /**
-         * Logs a debug message to the console (if enabled) and invokes the onDebug callback if provided.
-         * Controlled by GLOBAL_CONFIG.CC_LOGGER_ENABLE_CONSOLE for console output.
-        */
-        debug(topic, ...args) {
-            GLOBAL_CONFIG.CC_LOGGER_ENABLE_CONSOLE &&
-                console.debug(`[clientId=${this.clientId}]`, topic, ...args);
-            if (this.callbacks.onDebug) {
-                this.callbacks.onDebug(this.clientId, topic, ...args);
-            }
+    }
+    /**
+     * Logs a debug message to the console (if enabled) and invokes the onDebug callback if provided.
+     * Controlled by GLOBAL_CONFIG.CC_LOGGER_ENABLE_CONSOLE for console output.
+     */
+    debug(topic, ...args) {
+        GLOBAL_CONFIG.CC_LOGGER_ENABLE_CONSOLE &&
+            console.debug(`[clientId=${this.clientId}]`, topic, ...args);
+        if (this.callbacks.onDebug) {
+            this.callbacks.onDebug(this.clientId, topic, ...args);
         }
-        /**
-         * Logs an info message to the console (if enabled) and invokes the onInfo callback if provided.
-         * Controlled by GLOBAL_CONFIG.CC_LOGGER_ENABLE_CONSOLE for console output.
-        */
-        info(topic, ...args) {
-            GLOBAL_CONFIG.CC_LOGGER_ENABLE_CONSOLE &&
-                console.info(`[clientId=${this.clientId}]`, topic, ...args);
-            if (this.callbacks.onInfo) {
-                this.callbacks.onInfo(this.clientId, topic, ...args);
-            }
+    }
+    /**
+     * Logs an info message to the console (if enabled) and invokes the onInfo callback if provided.
+     * Controlled by GLOBAL_CONFIG.CC_LOGGER_ENABLE_CONSOLE for console output.
+     */
+    info(topic, ...args) {
+        GLOBAL_CONFIG.CC_LOGGER_ENABLE_CONSOLE &&
+            console.info(`[clientId=${this.clientId}]`, topic, ...args);
+        if (this.callbacks.onInfo) {
+            this.callbacks.onInfo(this.clientId, topic, ...args);
         }
-        /**
-         * Disposes of the logger instance, invoking the onDispose callback if provided.
-         * Performs synchronous cleanup without additional resource management.
-        */
-        dispose() {
-            if (this.callbacks.onDispose) {
-                this.callbacks.onDispose(this.clientId);
-            }
+    }
+    /**
+     * Disposes of the logger instance, invoking the onDispose callback if provided.
+     * Performs synchronous cleanup without additional resource management.
+     */
+    dispose() {
+        if (this.callbacks.onDispose) {
+            this.callbacks.onDispose(this.clientId);
         }
-    },
-    _a$2 = LOGGER_INSTANCE_WAIT_FOR_INIT,
-    _b));
+    }
+}
+_a$2 = LOGGER_INSTANCE_WAIT_FOR_INIT;
+// @ts-ignore
+LoggerInstance = functoolsKit.makeExtendable(LoggerInstance);
 /**
  * Provides utilities for managing logger instances and common logging operations.
  * Implements ILoggerAdapter for client-specific logging and ILoggerControl for configuration.
@@ -2360,7 +2364,7 @@ const LoggerInstance = functoolsKit.makeExtendable((_b = class {
  * MethodContextService (execution context), and GLOBAL_CONFIG (logging control).
  * @implements {ILoggerAdapter}
  * @implements {ILoggerControl}
-*/
+ */
 class LoggerUtils {
     constructor() {
         /** @private The custom logger instance constructor, defaults to LoggerInstance*/
@@ -2538,12 +2542,12 @@ class LoggerUtils {
 /**
  * Singleton instance of LoggerUtils implementing the logger adapter and control interfaces.
  * Provides a centralized utility for client-specific and common logging operations.
-*/
+ */
 const LoggerAdapter = new LoggerUtils();
 /**
  * Exported Logger Control interface for configuring logger behavior.
  * Exposes LoggerUtils' control methods (useCommonAdapter, useClientCallbacks, useClientAdapter, etc.).
-*/
+ */
 const Logger = LoggerAdapter;
 
 /** @private Constant for logging the constructor in OperatorInstance*/
@@ -2570,17 +2574,17 @@ const METHOD_NAME_CONNECT_OPERATOR = "OperatorUtils.connectOperator";
  * Operator instance implementation
  * @class OperatorInstance
  * @implements {IOperatorInstance}
-*/
-const OperatorInstance = functoolsKit.makeExtendable(class {
+ */
+class OperatorInstance {
     /**
      * Disposed flag for child class
-    */
+     */
     get isDisposed() {
         return this._isDisposed;
     }
     /**
      * Creates an OperatorInstance
-    */
+     */
     constructor(clientId, agentName, callbacks) {
         this.clientId = clientId;
         this.agentName = agentName;
@@ -2595,7 +2599,7 @@ const OperatorInstance = functoolsKit.makeExtendable(class {
     }
     /**
      * Connects an answer subscription
-    */
+     */
     connectAnswer(next) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
             swarm$1.loggerService.debug(OPERATOR_INSTANCE_METHOD_NAME_CONNECT_ANSWER, {
@@ -2607,7 +2611,7 @@ const OperatorInstance = functoolsKit.makeExtendable(class {
     }
     /**
      * Init the operator connection
-    */
+     */
     async init() {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
             swarm$1.loggerService.debug(OPERATOR_INSTANCE_METHOD_NAME_INIT, {
@@ -2620,7 +2624,7 @@ const OperatorInstance = functoolsKit.makeExtendable(class {
     }
     /**
      * Sends a notification
-    */
+     */
     async notify(content) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
             swarm$1.loggerService.debug(OPERATOR_INSTANCE_METHOD_NAME_NOTIFY, {
@@ -2637,7 +2641,7 @@ const OperatorInstance = functoolsKit.makeExtendable(class {
     }
     /**
      * Sends an answer
-    */
+     */
     async answer(content) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
             swarm$1.loggerService.debug(OPERATOR_INSTANCE_METHOD_NAME_ANSWER, {
@@ -2660,7 +2664,7 @@ const OperatorInstance = functoolsKit.makeExtendable(class {
     }
     /**
      * Receives a message
-    */
+     */
     async recieveMessage(message) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
             swarm$1.loggerService.debug(OPERATOR_INSTANCE_METHOD_NAME_RECEIVE_MESSAGE, {
@@ -2674,7 +2678,7 @@ const OperatorInstance = functoolsKit.makeExtendable(class {
     }
     /**
      * Disposes the operator instance
-    */
+     */
     async dispose() {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
             swarm$1.loggerService.debug(OPERATOR_INSTANCE_METHOD_NAME_DISPOSE, {
@@ -2687,12 +2691,14 @@ const OperatorInstance = functoolsKit.makeExtendable(class {
         this._answerSubject.unsubscribeAll();
         this._isDisposed = true;
     }
-});
+}
+// @ts-ignore
+OperatorInstance = functoolsKit.makeExtendable(OperatorInstance);
 /**
  * Operator utilities class
  * @class OperatorUtils
  * @implements {IOperatorControl}
-*/
+ */
 class OperatorUtils {
     constructor() {
         this.OperatorFactory = OperatorInstance;
@@ -23330,7 +23336,7 @@ const INACTIVITY_TIMEOUT = 15 * 60 * 1000;
 /**
  * @constant {Function} BEGIN_CHAT_FN
  * Function to begin a chat session
-*/
+ */
 const BEGIN_CHAT_FN = (self) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
         swarm$1.loggerService.debug("ChatInstance.beginChat", {
@@ -23345,11 +23351,11 @@ const BEGIN_CHAT_FN = (self) => {
  * @class ChatInstance
  * @implements {IChatInstance}
  * Implementation of a single chat instance
-*/
-const ChatInstance = functoolsKit.makeExtendable(class {
+ */
+class ChatInstance {
     /**
      * @constructor
-    */
+     */
     constructor(clientId, swarmName, onDispose, callbacks, payload) {
         this.clientId = clientId;
         this.swarmName = swarmName;
@@ -23362,7 +23368,7 @@ const ChatInstance = functoolsKit.makeExtendable(class {
         this._lastActivity = Date.now();
         /**
          * Begins a chat session
-        */
+         */
         this.beginChat = functoolsKit.singleshot(async () => {
             return await BEGIN_CHAT_FN(this);
         });
@@ -23379,7 +23385,7 @@ const ChatInstance = functoolsKit.makeExtendable(class {
     }
     /**
      * Checks if the chat has been active within the timeout period
-    */
+     */
     async checkLastActivity(now) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
             swarm$1.loggerService.debug("ChatInstance.checkLastActivity", {
@@ -23393,7 +23399,7 @@ const ChatInstance = functoolsKit.makeExtendable(class {
     }
     /**
      * Sends a message in the chat
-    */
+     */
     async sendMessage(content) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
             swarm$1.loggerService.debug("ChatInstance.sendMessage", {
@@ -23409,7 +23415,7 @@ const ChatInstance = functoolsKit.makeExtendable(class {
     }
     /**
      * Disposes of the chat instance
-    */
+     */
     async dispose() {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
             swarm$1.loggerService.debug("ChatInstance.dispose", {
@@ -23423,7 +23429,7 @@ const ChatInstance = functoolsKit.makeExtendable(class {
     }
     /**
      * Adds a listener for dispose events
-    */
+     */
     listenDispose(fn) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
             swarm$1.loggerService.debug("ChatInstance.listenDispose", {
@@ -23432,12 +23438,14 @@ const ChatInstance = functoolsKit.makeExtendable(class {
             });
         return this._disposeSubject.once(fn);
     }
-});
+}
+//@ts-ignore
+ChatInstance = functoolsKit.makeExtendable(ChatInstance);
 /**
  * @class ChatUtils
  * @implements {IChatControl}
  * Utility class for managing multiple chat instances
-*/
+ */
 class ChatUtils {
     constructor() {
         /** @private*/
@@ -23551,7 +23559,7 @@ class ChatUtils {
 /**
  * @constant {ChatUtils} Chat
  * Singleton instance of ChatUtils
-*/
+ */
 const Chat = new ChatUtils();
 
 /** @private Constant for logging the take method in StorageUtils*/