agent-swarm-kit 1.0.195 → 1.0.197

package/build/index.cjs

@@ -16849,6 +16849,201 @@ class SharedStateUtils {
  */
 const SharedState = new SharedStateUtils();
 
+/** @constant {string} */
+const CHAT_UTILS_METHOD_NAME_SEND_MESSAGE = "ChatUtils.sendMessage";
+/** @constant {string} */
+const CHAT_UTILS_METHOD_NAME_LISTEN_DISPOSE = "ChatUtils.listenDispose";
+/** @constant {string} */
+const CHAT_UTILS_METHOD_NAME_DISPOSE = "ChatUtils.dispose";
+/** @constant {string} */
+const CHAT_INSTANCE_METHOD_NAME_SEND_MESSAGE = "ChatInstance.sendMessage";
+/** @constant {string} */
+const CHAT_INSTANCE_METHOD_NAME_DISPOSE = "ChatInstance.dispose";
+/** @constant {string} */
+const CHAT_INSTANCE_METHOD_NAME_LISTEN_DISPOSE = "ChatInstance.listenDispose";
+/** @constant {number} Time interval in milliseconds for inactivity checks (1 minute) */
+const INACTIVITY_CHECK = 60 * 1000;
+/** @constant {number} Time in milliseconds before a chat is considered inactive (15 minutes) */
+const INACTIVITY_TIMEOUT = 15 * 60 * 1000;
+/**
+ * Represents a single chat instance for a client
+ * @class
+ */
+class ChatInstance {
+    /**
+     * Gets the timestamp of the last activity
+     * @public
+     * @returns {number} Last activity timestamp
+     */
+    get lastActivity() {
+        return this._lastActivity;
+    }
+    /**
+     * Creates a new ChatInstance
+     * @param {SessionId} clientId - The client identifier
+     * @param {SwarmName} swarmName - The swarm name
+     * @param {DisposeFn} onDispose - Callback function for disposal
+     */
+    constructor(clientId, swarmName, onDispose) {
+        this.clientId = clientId;
+        this.swarmName = swarmName;
+        this.onDispose = onDispose;
+        /** @private @type {Subject<SessionId>} Subject for disposal notifications */
+        this.disposeSubject = new functoolsKit.Subject();
+        /** @private @type {number} Timestamp of last activity */
+        this._lastActivity = Date.now();
+        /**
+         * Sends a message through the chat session
+         * @public
+         * @async
+         * @param {string} content - Message content to send
+         * @returns {Promise<any>} Result of the message completion
+         */
+        this.sendMessage = async (content) => {
+            GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
+                swarm$1.loggerService.debug(CHAT_INSTANCE_METHOD_NAME_SEND_MESSAGE, {
+                    content,
+                    clientId: this.clientId,
+                    swarmName: this.swarmName,
+                    timestamp: new Date().toISOString(),
+                });
+            this._lastActivity = Date.now();
+            return await this.chatSession.complete(content);
+        };
+        /**
+         * Disposes of the chat instance
+         * @public
+         * @async
+         * @returns {Promise<void>}
+         */
+        this.dispose = async () => {
+            GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
+                swarm$1.loggerService.debug(CHAT_INSTANCE_METHOD_NAME_DISPOSE, {
+                    clientId: this.clientId,
+                    swarmName: this.swarmName,
+                    timestamp: new Date().toISOString(),
+                });
+            await this.disposeSubject.next(this.clientId);
+            await this.chatSession.dispose();
+        };
+        /**
+         * Subscribes to disposal events
+         * @public
+         * @param {(clientId: SessionId) => void} fn - Callback function for disposal events
+         * @returns {any} Subscription object
+         */
+        this.listenDispose = (fn) => {
+            GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
+                swarm$1.loggerService.debug(CHAT_INSTANCE_METHOD_NAME_LISTEN_DISPOSE, {
+                    clientId: this.clientId,
+                    swarmName: this.swarmName,
+                });
+            return this.disposeSubject.once(fn);
+        };
+        this.chatSession = session(this.clientId, this.swarmName, {
+            onDispose: this.onDispose,
+        });
+    }
+}
+/**
+ * Utility class for managing multiple chat instances
+ * @class
+ */
+class ChatUtils {
+    constructor() {
+        /** @private @type {Map<SessionId, ChatInstance>} Map of active chat instances */
+        this._chats = new Map();
+        /**
+         * Initializes cleanup interval for inactive chats
+         * @private
+         * @returns {void}
+         */
+        this.initializeCleanup = functoolsKit.singleshot(() => {
+            const handleCleanup = async () => {
+                const now = Date.now();
+                for (const chat of this._chats.values()) {
+                    if (now - chat.lastActivity >= INACTIVITY_TIMEOUT) {
+                        await chat.dispose();
+                    }
+                }
+            };
+            setInterval(handleCleanup, INACTIVITY_CHECK);
+        });
+        /**
+         * Gets or creates a chat instance for a client
+         * @private
+         * @param {SessionId} clientId - The client identifier
+         * @param {SwarmName} swarmName - The swarm name
+         * @returns {ChatInstance} Chat instance for the client
+         */
+        this.getChatInstance = (clientId, swarmName) => {
+            return this._chats.has(clientId)
+                ? this._chats.get(clientId)
+                : this._chats
+                    .set(clientId, new ChatInstance(clientId, swarmName, () => {
+                    this._chats.delete(clientId);
+                }))
+                    .get(clientId);
+        };
+        /**
+         * Sends a message for a specific client
+         * @public
+         * @async
+         * @param {SessionId} clientId - The client identifier
+         * @param {string} message - Message content to send
+         * @param {SwarmName} swarmName - The swarm name
+         * @returns {Promise<any>} Result of the message sending
+         */
+        this.sendMessage = async (clientId, message, swarmName) => {
+            GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
+                swarm$1.loggerService.log(CHAT_UTILS_METHOD_NAME_SEND_MESSAGE, {
+                    clientId,
+                    message,
+                    swarmName,
+                });
+            this.initializeCleanup();
+            return await this.getChatInstance(clientId, swarmName).sendMessage(message);
+        };
+        /**
+         * Subscribes to disposal events for a specific client
+         * @public
+         * @param {SessionId} clientId - The client identifier
+         * @param {SwarmName} swarmName - The swarm name
+         * @param {(clientId: SessionId) => void} fn - Callback function for disposal events
+         * @returns {any} Subscription object
+         */
+        this.listenDispose = (clientId, swarmName, fn) => {
+            GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
+                swarm$1.loggerService.log(CHAT_UTILS_METHOD_NAME_LISTEN_DISPOSE, {
+                    clientId,
+                    swarmName,
+                });
+            return this.getChatInstance(clientId, swarmName).listenDispose(fn);
+        };
+        /**
+         * Disposes of a specific chat instance for a client
+         * @public
+         * @async
+         * @param {SessionId} clientId - The client identifier for the chat instance to dispose
+         * @param {SwarmName} swarmName - The swarm name associated with the chat instance
+         * @returns {Promise<void>} A promise that resolves when the chat instance has been disposed
+         */
+        this.dispose = async (clientId, swarmName) => {
+            GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
+                swarm$1.loggerService.log(CHAT_UTILS_METHOD_NAME_DISPOSE, {
+                    clientId,
+                    swarmName,
+                });
+            if (!this._chats.has(clientId)) {
+                return;
+            }
+            return await this.getChatInstance(clientId, swarmName).dispose();
+        };
+    }
+}
+/** @constant {ChatUtils} Singleton instance of ChatUtils */
+const Chat = new ChatUtils();
+
 /** @private Constant for logging the take method in StorageUtils */
 const METHOD_NAME_TAKE$1 = "StorageUtils.take";
 /** @private Constant for logging the upsert method in StorageUtils */
@@ -17633,6 +17828,7 @@ const Utils = {
 };
 
 exports.Adapter = Adapter;
+exports.Chat = Chat;
 exports.ExecutionContextService = ExecutionContextService;
 exports.History = History;
 exports.HistoryMemoryInstance = HistoryMemoryInstance;

package/build/index.mjs

@@ -16847,6 +16847,201 @@ class SharedStateUtils {
  */
 const SharedState = new SharedStateUtils();
 
+/** @constant {string} */
+const CHAT_UTILS_METHOD_NAME_SEND_MESSAGE = "ChatUtils.sendMessage";
+/** @constant {string} */
+const CHAT_UTILS_METHOD_NAME_LISTEN_DISPOSE = "ChatUtils.listenDispose";
+/** @constant {string} */
+const CHAT_UTILS_METHOD_NAME_DISPOSE = "ChatUtils.dispose";
+/** @constant {string} */
+const CHAT_INSTANCE_METHOD_NAME_SEND_MESSAGE = "ChatInstance.sendMessage";
+/** @constant {string} */
+const CHAT_INSTANCE_METHOD_NAME_DISPOSE = "ChatInstance.dispose";
+/** @constant {string} */
+const CHAT_INSTANCE_METHOD_NAME_LISTEN_DISPOSE = "ChatInstance.listenDispose";
+/** @constant {number} Time interval in milliseconds for inactivity checks (1 minute) */
+const INACTIVITY_CHECK = 60 * 1000;
+/** @constant {number} Time in milliseconds before a chat is considered inactive (15 minutes) */
+const INACTIVITY_TIMEOUT = 15 * 60 * 1000;
+/**
+ * Represents a single chat instance for a client
+ * @class
+ */
+class ChatInstance {
+    /**
+     * Gets the timestamp of the last activity
+     * @public
+     * @returns {number} Last activity timestamp
+     */
+    get lastActivity() {
+        return this._lastActivity;
+    }
+    /**
+     * Creates a new ChatInstance
+     * @param {SessionId} clientId - The client identifier
+     * @param {SwarmName} swarmName - The swarm name
+     * @param {DisposeFn} onDispose - Callback function for disposal
+     */
+    constructor(clientId, swarmName, onDispose) {
+        this.clientId = clientId;
+        this.swarmName = swarmName;
+        this.onDispose = onDispose;
+        /** @private @type {Subject<SessionId>} Subject for disposal notifications */
+        this.disposeSubject = new Subject();
+        /** @private @type {number} Timestamp of last activity */
+        this._lastActivity = Date.now();
+        /**
+         * Sends a message through the chat session
+         * @public
+         * @async
+         * @param {string} content - Message content to send
+         * @returns {Promise<any>} Result of the message completion
+         */
+        this.sendMessage = async (content) => {
+            GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
+                swarm$1.loggerService.debug(CHAT_INSTANCE_METHOD_NAME_SEND_MESSAGE, {
+                    content,
+                    clientId: this.clientId,
+                    swarmName: this.swarmName,
+                    timestamp: new Date().toISOString(),
+                });
+            this._lastActivity = Date.now();
+            return await this.chatSession.complete(content);
+        };
+        /**
+         * Disposes of the chat instance
+         * @public
+         * @async
+         * @returns {Promise<void>}
+         */
+        this.dispose = async () => {
+            GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
+                swarm$1.loggerService.debug(CHAT_INSTANCE_METHOD_NAME_DISPOSE, {
+                    clientId: this.clientId,
+                    swarmName: this.swarmName,
+                    timestamp: new Date().toISOString(),
+                });
+            await this.disposeSubject.next(this.clientId);
+            await this.chatSession.dispose();
+        };
+        /**
+         * Subscribes to disposal events
+         * @public
+         * @param {(clientId: SessionId) => void} fn - Callback function for disposal events
+         * @returns {any} Subscription object
+         */
+        this.listenDispose = (fn) => {
+            GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
+                swarm$1.loggerService.debug(CHAT_INSTANCE_METHOD_NAME_LISTEN_DISPOSE, {
+                    clientId: this.clientId,
+                    swarmName: this.swarmName,
+                });
+            return this.disposeSubject.once(fn);
+        };
+        this.chatSession = session(this.clientId, this.swarmName, {
+            onDispose: this.onDispose,
+        });
+    }
+}
+/**
+ * Utility class for managing multiple chat instances
+ * @class
+ */
+class ChatUtils {
+    constructor() {
+        /** @private @type {Map<SessionId, ChatInstance>} Map of active chat instances */
+        this._chats = new Map();
+        /**
+         * Initializes cleanup interval for inactive chats
+         * @private
+         * @returns {void}
+         */
+        this.initializeCleanup = singleshot(() => {
+            const handleCleanup = async () => {
+                const now = Date.now();
+                for (const chat of this._chats.values()) {
+                    if (now - chat.lastActivity >= INACTIVITY_TIMEOUT) {
+                        await chat.dispose();
+                    }
+                }
+            };
+            setInterval(handleCleanup, INACTIVITY_CHECK);
+        });
+        /**
+         * Gets or creates a chat instance for a client
+         * @private
+         * @param {SessionId} clientId - The client identifier
+         * @param {SwarmName} swarmName - The swarm name
+         * @returns {ChatInstance} Chat instance for the client
+         */
+        this.getChatInstance = (clientId, swarmName) => {
+            return this._chats.has(clientId)
+                ? this._chats.get(clientId)
+                : this._chats
+                    .set(clientId, new ChatInstance(clientId, swarmName, () => {
+                    this._chats.delete(clientId);
+                }))
+                    .get(clientId);
+        };
+        /**
+         * Sends a message for a specific client
+         * @public
+         * @async
+         * @param {SessionId} clientId - The client identifier
+         * @param {string} message - Message content to send
+         * @param {SwarmName} swarmName - The swarm name
+         * @returns {Promise<any>} Result of the message sending
+         */
+        this.sendMessage = async (clientId, message, swarmName) => {
+            GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
+                swarm$1.loggerService.log(CHAT_UTILS_METHOD_NAME_SEND_MESSAGE, {
+                    clientId,
+                    message,
+                    swarmName,
+                });
+            this.initializeCleanup();
+            return await this.getChatInstance(clientId, swarmName).sendMessage(message);
+        };
+        /**
+         * Subscribes to disposal events for a specific client
+         * @public
+         * @param {SessionId} clientId - The client identifier
+         * @param {SwarmName} swarmName - The swarm name
+         * @param {(clientId: SessionId) => void} fn - Callback function for disposal events
+         * @returns {any} Subscription object
+         */
+        this.listenDispose = (clientId, swarmName, fn) => {
+            GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
+                swarm$1.loggerService.log(CHAT_UTILS_METHOD_NAME_LISTEN_DISPOSE, {
+                    clientId,
+                    swarmName,
+                });
+            return this.getChatInstance(clientId, swarmName).listenDispose(fn);
+        };
+        /**
+         * Disposes of a specific chat instance for a client
+         * @public
+         * @async
+         * @param {SessionId} clientId - The client identifier for the chat instance to dispose
+         * @param {SwarmName} swarmName - The swarm name associated with the chat instance
+         * @returns {Promise<void>} A promise that resolves when the chat instance has been disposed
+         */
+        this.dispose = async (clientId, swarmName) => {
+            GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
+                swarm$1.loggerService.log(CHAT_UTILS_METHOD_NAME_DISPOSE, {
+                    clientId,
+                    swarmName,
+                });
+            if (!this._chats.has(clientId)) {
+                return;
+            }
+            return await this.getChatInstance(clientId, swarmName).dispose();
+        };
+    }
+}
+/** @constant {ChatUtils} Singleton instance of ChatUtils */
+const Chat = new ChatUtils();
+
 /** @private Constant for logging the take method in StorageUtils */
 const METHOD_NAME_TAKE$1 = "StorageUtils.take";
 /** @private Constant for logging the upsert method in StorageUtils */
@@ -17630,4 +17825,4 @@ const Utils = {
     PersistEmbeddingUtils,
 };
 
-export { Adapter, ExecutionContextService, History, HistoryMemoryInstance, HistoryPersistInstance, Logger, LoggerInstance, MethodContextService, PayloadContextService, PersistAlive, PersistBase, PersistEmbedding, PersistList, PersistMemory, PersistPolicy, PersistState, PersistStorage, PersistSwarm, Policy, RoundRobin, Schema, SharedState, SharedStorage, State, Storage, Utils, addAgent, addCompletion, addEmbedding, addPolicy, addState, addStorage, addSwarm, addTool, beginContext, cancelOutput, cancelOutputForce, changeToAgent, changeToDefaultAgent, changeToPrevAgent, commitAssistantMessage, commitAssistantMessageForce, commitFlush, commitFlushForce, commitStopTools, commitStopToolsForce, commitSystemMessage, commitSystemMessageForce, commitToolOutput, commitToolOutputForce, commitUserMessage, commitUserMessageForce, complete, disposeConnection, dumpAgent, dumpClientPerformance, dumpDocs, dumpPerfomance, dumpSwarm, emit, emitForce, event, execute, executeForce, getAgentHistory, getAgentName, getAssistantHistory, getLastAssistantMessage, getLastSystemMessage, getLastUserMessage, getPayload, getRawHistory, getSessionContext, getSessionMode, getUserHistory, listenAgentEvent, listenAgentEventOnce, listenEvent, listenEventOnce, listenExecutionEvent, listenExecutionEventOnce, listenHistoryEvent, listenHistoryEventOnce, listenPolicyEvent, listenPolicyEventOnce, listenSessionEvent, listenSessionEventOnce, listenStateEvent, listenStateEventOnce, listenStorageEvent, listenStorageEventOnce, listenSwarmEvent, listenSwarmEventOnce, makeAutoDispose, makeConnection, markOffline, markOnline, runStateless, runStatelessForce, session, setConfig, swarm };
+export { Adapter, Chat, ExecutionContextService, History, HistoryMemoryInstance, HistoryPersistInstance, Logger, LoggerInstance, MethodContextService, PayloadContextService, PersistAlive, PersistBase, PersistEmbedding, PersistList, PersistMemory, PersistPolicy, PersistState, PersistStorage, PersistSwarm, Policy, RoundRobin, Schema, SharedState, SharedStorage, State, Storage, Utils, addAgent, addCompletion, addEmbedding, addPolicy, addState, addStorage, addSwarm, addTool, beginContext, cancelOutput, cancelOutputForce, changeToAgent, changeToDefaultAgent, changeToPrevAgent, commitAssistantMessage, commitAssistantMessageForce, commitFlush, commitFlushForce, commitStopTools, commitStopToolsForce, commitSystemMessage, commitSystemMessageForce, commitToolOutput, commitToolOutputForce, commitUserMessage, commitUserMessageForce, complete, disposeConnection, dumpAgent, dumpClientPerformance, dumpDocs, dumpPerfomance, dumpSwarm, emit, emitForce, event, execute, executeForce, getAgentHistory, getAgentName, getAssistantHistory, getLastAssistantMessage, getLastSystemMessage, getLastUserMessage, getPayload, getRawHistory, getSessionContext, getSessionMode, getUserHistory, listenAgentEvent, listenAgentEventOnce, listenEvent, listenEventOnce, listenExecutionEvent, listenExecutionEventOnce, listenHistoryEvent, listenHistoryEventOnce, listenPolicyEvent, listenPolicyEventOnce, listenSessionEvent, listenSessionEventOnce, listenStateEvent, listenStateEventOnce, listenStorageEvent, listenStorageEventOnce, listenSwarmEvent, listenSwarmEventOnce, makeAutoDispose, makeConnection, markOffline, markOnline, runStateless, runStatelessForce, session, setConfig, swarm };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-swarm-kit",
-  "version": "1.0.195",
+  "version": "1.0.197",
   "description": "A TypeScript library for building orchestrated framework-agnostic multi-agent AI systems",
   "author": {
     "name": "Petr Tripolsky",

package/types.d.ts

@@ -10469,6 +10469,59 @@ declare class SharedStateUtils implements TSharedState {
  */
 declare const SharedState: SharedStateUtils;
 
+/**
+ * Utility class for managing multiple chat instances
+ * @class
+ */
+declare class ChatUtils {
+    /** @private @type {Map<SessionId, ChatInstance>} Map of active chat instances */
+    private _chats;
+    /**
+     * Initializes cleanup interval for inactive chats
+     * @private
+     * @returns {void}
+     */
+    private initializeCleanup;
+    /**
+     * Gets or creates a chat instance for a client
+     * @private
+     * @param {SessionId} clientId - The client identifier
+     * @param {SwarmName} swarmName - The swarm name
+     * @returns {ChatInstance} Chat instance for the client
+     */
+    private getChatInstance;
+    /**
+     * Sends a message for a specific client
+     * @public
+     * @async
+     * @param {SessionId} clientId - The client identifier
+     * @param {string} message - Message content to send
+     * @param {SwarmName} swarmName - The swarm name
+     * @returns {Promise<any>} Result of the message sending
+     */
+    sendMessage: (clientId: SessionId, message: string, swarmName: SwarmName) => Promise<string>;
+    /**
+     * Subscribes to disposal events for a specific client
+     * @public
+     * @param {SessionId} clientId - The client identifier
+     * @param {SwarmName} swarmName - The swarm name
+     * @param {(clientId: SessionId) => void} fn - Callback function for disposal events
+     * @returns {any} Subscription object
+     */
+    listenDispose: (clientId: SessionId, swarmName: SwarmName, fn: (clientId: SessionId) => void) => () => void;
+    /**
+     * Disposes of a specific chat instance for a client
+     * @public
+     * @async
+     * @param {SessionId} clientId - The client identifier for the chat instance to dispose
+     * @param {SwarmName} swarmName - The swarm name associated with the chat instance
+     * @returns {Promise<void>} A promise that resolves when the chat instance has been disposed
+     */
+    dispose: (clientId: SessionId, swarmName: SwarmName) => Promise<void>;
+}
+/** @constant {ChatUtils} Singleton instance of ChatUtils */
+declare const Chat: ChatUtils;
+
 /**
  * Type definition for a storage object, mapping IStorage keys to unknown values.
  * @typedef {{ [key in keyof IStorage]: unknown }} TStorage
@@ -10837,4 +10890,4 @@ declare const Utils: {
     PersistEmbeddingUtils: typeof PersistEmbeddingUtils;
 };
 
-export { Adapter, type EventSource, ExecutionContextService, History, HistoryMemoryInstance, HistoryPersistInstance, type IAgentSchema, type IAgentTool, type IBaseEvent, type IBusEvent, type IBusEventContext, type ICompletionArgs, type ICompletionSchema, type ICustomEvent, type IEmbeddingSchema, type IGlobalConfig, type IHistoryAdapter, type IHistoryControl, type IHistoryInstance, type IHistoryInstanceCallbacks, type IIncomingMessage, type ILoggerAdapter, type ILoggerInstance, type ILoggerInstanceCallbacks, type IMakeConnectionConfig, type IMakeDisposeParams, type IModelMessage, type IOutgoingMessage, type IPersistActiveAgentData, type IPersistAliveData, type IPersistBase, type IPersistEmbeddingData, type IPersistMemoryData, type IPersistNavigationStackData, type IPersistPolicyData, type IPersistStateData, type IPersistStorageData, type IPolicySchema, type ISessionConfig, type IStateSchema, type IStorageData, type IStorageSchema, type ISwarmSchema, type ITool, type IToolCall, Logger, LoggerInstance, MethodContextService, PayloadContextService, PersistAlive, PersistBase, PersistEmbedding, PersistList, PersistMemory, PersistPolicy, PersistState, PersistStorage, PersistSwarm, Policy, type ReceiveMessageFn, RoundRobin, Schema, type SendMessageFn, SharedState, SharedStorage, State, Storage, type THistoryInstanceCtor, type THistoryMemoryInstance, type THistoryPersistInstance, type TLoggerInstance, type TPersistBase, type TPersistBaseCtor, type TPersistList, Utils, addAgent, addCompletion, addEmbedding, addPolicy, addState, addStorage, addSwarm, addTool, beginContext, cancelOutput, cancelOutputForce, changeToAgent, changeToDefaultAgent, changeToPrevAgent, commitAssistantMessage, commitAssistantMessageForce, commitFlush, commitFlushForce, commitStopTools, commitStopToolsForce, commitSystemMessage, commitSystemMessageForce, commitToolOutput, commitToolOutputForce, commitUserMessage, commitUserMessageForce, complete, disposeConnection, dumpAgent, dumpClientPerformance, dumpDocs, dumpPerfomance, dumpSwarm, emit, emitForce, event, execute, executeForce, getAgentHistory, getAgentName, getAssistantHistory, getLastAssistantMessage, getLastSystemMessage, getLastUserMessage, getPayload, getRawHistory, getSessionContext, getSessionMode, getUserHistory, listenAgentEvent, listenAgentEventOnce, listenEvent, listenEventOnce, listenExecutionEvent, listenExecutionEventOnce, listenHistoryEvent, listenHistoryEventOnce, listenPolicyEvent, listenPolicyEventOnce, listenSessionEvent, listenSessionEventOnce, listenStateEvent, listenStateEventOnce, listenStorageEvent, listenStorageEventOnce, listenSwarmEvent, listenSwarmEventOnce, makeAutoDispose, makeConnection, markOffline, markOnline, runStateless, runStatelessForce, session, setConfig, swarm };
+export { Adapter, Chat, type EventSource, ExecutionContextService, History, HistoryMemoryInstance, HistoryPersistInstance, type IAgentSchema, type IAgentTool, type IBaseEvent, type IBusEvent, type IBusEventContext, type ICompletionArgs, type ICompletionSchema, type ICustomEvent, type IEmbeddingSchema, type IGlobalConfig, type IHistoryAdapter, type IHistoryControl, type IHistoryInstance, type IHistoryInstanceCallbacks, type IIncomingMessage, type ILoggerAdapter, type ILoggerInstance, type ILoggerInstanceCallbacks, type IMakeConnectionConfig, type IMakeDisposeParams, type IModelMessage, type IOutgoingMessage, type IPersistActiveAgentData, type IPersistAliveData, type IPersistBase, type IPersistEmbeddingData, type IPersistMemoryData, type IPersistNavigationStackData, type IPersistPolicyData, type IPersistStateData, type IPersistStorageData, type IPolicySchema, type ISessionConfig, type IStateSchema, type IStorageData, type IStorageSchema, type ISwarmSchema, type ITool, type IToolCall, Logger, LoggerInstance, MethodContextService, PayloadContextService, PersistAlive, PersistBase, PersistEmbedding, PersistList, PersistMemory, PersistPolicy, PersistState, PersistStorage, PersistSwarm, Policy, type ReceiveMessageFn, RoundRobin, Schema, type SendMessageFn, SharedState, SharedStorage, State, Storage, type THistoryInstanceCtor, type THistoryMemoryInstance, type THistoryPersistInstance, type TLoggerInstance, type TPersistBase, type TPersistBaseCtor, type TPersistList, Utils, addAgent, addCompletion, addEmbedding, addPolicy, addState, addStorage, addSwarm, addTool, beginContext, cancelOutput, cancelOutputForce, changeToAgent, changeToDefaultAgent, changeToPrevAgent, commitAssistantMessage, commitAssistantMessageForce, commitFlush, commitFlushForce, commitStopTools, commitStopToolsForce, commitSystemMessage, commitSystemMessageForce, commitToolOutput, commitToolOutputForce, commitUserMessage, commitUserMessageForce, complete, disposeConnection, dumpAgent, dumpClientPerformance, dumpDocs, dumpPerfomance, dumpSwarm, emit, emitForce, event, execute, executeForce, getAgentHistory, getAgentName, getAssistantHistory, getLastAssistantMessage, getLastSystemMessage, getLastUserMessage, getPayload, getRawHistory, getSessionContext, getSessionMode, getUserHistory, listenAgentEvent, listenAgentEventOnce, listenEvent, listenEventOnce, listenExecutionEvent, listenExecutionEventOnce, listenHistoryEvent, listenHistoryEventOnce, listenPolicyEvent, listenPolicyEventOnce, listenSessionEvent, listenSessionEventOnce, listenStateEvent, listenStateEventOnce, listenStorageEvent, listenStorageEventOnce, listenSwarmEvent, listenSwarmEventOnce, makeAutoDispose, makeConnection, markOffline, markOnline, runStateless, runStatelessForce, session, setConfig, swarm };