agent-swarm-kit 1.0.204 → 1.0.206

package/build/index.cjs

@@ -4228,7 +4228,7 @@ class AgentConnectionService {
 }
 
 /** @private Constant defining the method name for logging purposes */
-const METHOD_NAME$U = "function.common.getPayload";
+const METHOD_NAME$V = "function.common.getPayload";
 /**
  * Retrieves the payload from the current PayloadContextService context.
  * Returns null if no context is available. Logs the operation if logging is enabled.
@@ -4239,7 +4239,7 @@ const METHOD_NAME$U = "function.common.getPayload";
  * console.log(payload); // { id: number } or null
  */
 const getPayload = () => {
-    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$U);
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$V);
     if (PayloadContextService.hasContext()) {
         const { payload } = swarm$1.payloadContextService.context;
         return payload;
@@ -13155,7 +13155,7 @@ const swarm = {
 init();
 var swarm$1 = swarm;
 
-const METHOD_NAME$T = "cli.dumpDocs";
+const METHOD_NAME$U = "cli.dumpDocs";
 /**
  * Dumps the documentation for the agents and swarms.
  *
@@ -13165,7 +13165,7 @@ const METHOD_NAME$T = "cli.dumpDocs";
  */
 const dumpDocs = beginContext((dirName = "./docs/chat", PlantUML) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$T, {
+        swarm$1.loggerService.log(METHOD_NAME$U, {
             dirName,
         });
     if (PlantUML) {
@@ -13175,10 +13175,10 @@ const dumpDocs = beginContext((dirName = "./docs/chat", PlantUML) => {
     }
     swarm$1.agentValidationService
         .getAgentList()
-        .forEach((agentName) => swarm$1.agentValidationService.validate(agentName, METHOD_NAME$T));
+        .forEach((agentName) => swarm$1.agentValidationService.validate(agentName, METHOD_NAME$U));
     swarm$1.swarmValidationService
         .getSwarmList()
-        .forEach((swarmName) => swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$T));
+        .forEach((swarmName) => swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$U));
     swarm$1.agentValidationService.getAgentList().forEach((agentName) => {
         const { dependsOn } = swarm$1.agentSchemaService.get(agentName);
         if (!dependsOn) {
@@ -13188,7 +13188,7 @@ const dumpDocs = beginContext((dirName = "./docs/chat", PlantUML) => {
     return swarm$1.docService.dumpDocs(dirName);
 });
 
-const METHOD_NAME$S = "cli.dumpAgent";
+const METHOD_NAME$T = "cli.dumpAgent";
 /**
  * Dumps the agent information into PlantUML format.
  *
@@ -13197,14 +13197,14 @@ const METHOD_NAME$S = "cli.dumpAgent";
  */
 const dumpAgent = beginContext((agentName, { withSubtree = false } = {}) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$S, {
+        swarm$1.loggerService.log(METHOD_NAME$T, {
             agentName,
         });
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$S);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$T);
     return swarm$1.agentMetaService.toUML(agentName, withSubtree);
 });
 
-const METHOD_NAME$R = "cli.dumpSwarm";
+const METHOD_NAME$S = "cli.dumpSwarm";
 /**
  * Dumps the swarm information into PlantUML format.
  *
@@ -13213,14 +13213,14 @@ const METHOD_NAME$R = "cli.dumpSwarm";
  */
 const dumpSwarm = beginContext((swarmName) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$R, {
+        swarm$1.loggerService.log(METHOD_NAME$S, {
             swarmName,
         });
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$R);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$S);
     return swarm$1.swarmMetaService.toUML(swarmName);
 });
 
-const METHOD_NAME$Q = "cli.dumpPerfomance";
+const METHOD_NAME$R = "cli.dumpPerfomance";
 const METHOD_NAME_INTERNAL$1 = "cli.dumpPerfomance.internal";
 const METHOD_NAME_INTERVAL = "cli.dumpPerfomance.interval";
 /**
@@ -13239,7 +13239,7 @@ const dumpPerfomanceInternal = beginContext(async (dirName = "./logs/meta") => {
  * @returns {Promise<void>} A promise that resolves when the performance data has been dumped.
  */
 const dumpPerfomance = async (dirName = "./logs/meta") => {
-    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$Q);
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$R);
     await dumpPerfomanceInternal(dirName);
 };
 /**
@@ -13297,7 +13297,7 @@ const listenExecutionEvent = beginContext((clientId, fn) => {
     return swarm$1.busService.subscribe(clientId, "execution-bus", functoolsKit.queued(async (e) => await fn(e)));
 });
 
-const METHOD_NAME$P = "cli.dumpClientPerformance";
+const METHOD_NAME$Q = "cli.dumpClientPerformance";
 const METHOD_NAME_INTERNAL = "cli.dumpClientPerformance.internal";
 const METHOD_NAME_EXECUTE = "cli.dumpClientPerformance.execute";
 /**
@@ -13321,7 +13321,7 @@ const dumpClientPerformanceInternal = beginContext(async (clientId, dirName = ".
  * @returns {Promise<void>} A promise that resolves when the performance data has been dumped.
  */
 const dumpClientPerformance = async (clientId, dirName = "./logs/client") => {
-    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$P);
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$Q);
     await dumpClientPerformanceInternal(clientId, dirName);
 };
 /**
@@ -13341,7 +13341,7 @@ dumpClientPerformance.runAfterExecute = beginContext(async (dirName = "./logs/cl
     });
 });
 
-const METHOD_NAME$O = "function.setup.addAgent";
+const METHOD_NAME$P = "function.setup.addAgent";
 /**
  * Adds a new agent to the agent registry for use within the swarm system.
  *
@@ -13361,7 +13361,7 @@ const METHOD_NAME$O = "function.setup.addAgent";
 const addAgent = beginContext((agentSchema) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$O, {
+        swarm$1.loggerService.log(METHOD_NAME$P, {
             agentSchema,
         });
     // Register the agent in the validation and schema services
@@ -13371,7 +13371,7 @@ const addAgent = beginContext((agentSchema) => {
     return agentSchema.agentName;
 });
 
-const METHOD_NAME$N = "function.setup.addCompletion";
+const METHOD_NAME$O = "function.setup.addCompletion";
 /**
  * Adds a completion engine to the registry for use by agents in the swarm system.
  *
@@ -13391,7 +13391,7 @@ const METHOD_NAME$N = "function.setup.addCompletion";
 const addCompletion = beginContext((completionSchema) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$N, {
+        swarm$1.loggerService.log(METHOD_NAME$O, {
             completionSchema,
         });
     // Register the completion in the validation and schema services
@@ -13401,7 +13401,7 @@ const addCompletion = beginContext((completionSchema) => {
     return completionSchema.completionName;
 });
 
-const METHOD_NAME$M = "function.setup.addSwarm";
+const METHOD_NAME$N = "function.setup.addSwarm";
 /**
  * Adds a new swarm to the system for managing client sessions.
  *
@@ -13421,7 +13421,7 @@ const METHOD_NAME$M = "function.setup.addSwarm";
 const addSwarm = beginContext((swarmSchema) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$M, {
+        swarm$1.loggerService.log(METHOD_NAME$N, {
             swarmSchema,
         });
     // Register the swarm in the validation and schema services
@@ -13431,7 +13431,7 @@ const addSwarm = beginContext((swarmSchema) => {
     return swarmSchema.swarmName;
 });
 
-const METHOD_NAME$L = "function.setup.addTool";
+const METHOD_NAME$M = "function.setup.addTool";
 /**
  * Adds a new tool to the tool registry for use by agents in the swarm system.
  *
@@ -13453,7 +13453,7 @@ const METHOD_NAME$L = "function.setup.addTool";
 const addTool = beginContext((toolSchema) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$L, {
+        swarm$1.loggerService.log(METHOD_NAME$M, {
             toolSchema,
         });
     // Register the tool in the validation and schema services
@@ -13463,7 +13463,7 @@ const addTool = beginContext((toolSchema) => {
     return toolSchema.toolName;
 });
 
-const METHOD_NAME$K = "function.setup.addState";
+const METHOD_NAME$L = "function.setup.addState";
 /**
  * Adds a new state to the state registry for use within the swarm system.
  *
@@ -13485,7 +13485,7 @@ const METHOD_NAME$K = "function.setup.addState";
 const addState = beginContext((stateSchema) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$K, {
+        swarm$1.loggerService.log(METHOD_NAME$L, {
             stateSchema,
         });
     // Register the state in the schema service
@@ -13500,7 +13500,7 @@ const addState = beginContext((stateSchema) => {
     return stateSchema.stateName;
 });
 
-const METHOD_NAME$J = "function.setup.addEmbedding";
+const METHOD_NAME$K = "function.setup.addEmbedding";
 /**
  * Adds a new embedding engine to the embedding registry for use within the swarm system.
  *
@@ -13520,7 +13520,7 @@ const METHOD_NAME$J = "function.setup.addEmbedding";
 const addEmbedding = beginContext((embeddingSchema) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$J, {
+        swarm$1.loggerService.log(METHOD_NAME$K, {
             embeddingSchema,
         });
     // Register the embedding in the validation and schema services
@@ -13530,7 +13530,7 @@ const addEmbedding = beginContext((embeddingSchema) => {
     return embeddingSchema.embeddingName;
 });
 
-const METHOD_NAME$I = "function.setup.addStorage";
+const METHOD_NAME$J = "function.setup.addStorage";
 /**
  * Adds a new storage engine to the storage registry for use within the swarm system.
  *
@@ -13552,7 +13552,7 @@ const METHOD_NAME$I = "function.setup.addStorage";
 const addStorage = beginContext((storageSchema) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$I, {
+        swarm$1.loggerService.log(METHOD_NAME$J, {
             storageSchema,
         });
     // Register the storage in the validation and schema services
@@ -13569,7 +13569,7 @@ const addStorage = beginContext((storageSchema) => {
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$H = "function.setup.addPolicy";
+const METHOD_NAME$I = "function.setup.addPolicy";
 /**
  * Adds a new policy for agents in the swarm system by registering it with validation and schema services.
  * Registers the policy with PolicyValidationService for runtime validation and PolicySchemaService for schema management.
@@ -13585,7 +13585,7 @@ const METHOD_NAME$H = "function.setup.addPolicy";
 const addPolicy = beginContext((policySchema) => {
     // Log the policy addition attempt if enabled
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$H, {
+        swarm$1.loggerService.log(METHOD_NAME$I, {
             policySchema,
         });
     // Register the policy with PolicyValidationService for runtime validation
@@ -13596,17 +13596,17 @@ const addPolicy = beginContext((policySchema) => {
     return policySchema.policyName;
 });
 
-const METHOD_NAME$G = "function.other.markOnline";
+const METHOD_NAME$H = "function.other.markOnline";
 const markOnline = async (clientId, swarmName) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm.loggerService.log(METHOD_NAME$G, {
+        swarm.loggerService.log(METHOD_NAME$H, {
             clientId,
         });
-    swarm.swarmValidationService.validate(swarmName, METHOD_NAME$G);
+    swarm.swarmValidationService.validate(swarmName, METHOD_NAME$H);
     return await MethodContextService.runInContext(async () => {
-        await swarm.aliveService.markOnline(clientId, swarmName, METHOD_NAME$G);
+        await swarm.aliveService.markOnline(clientId, swarmName, METHOD_NAME$H);
     }, {
-        methodName: METHOD_NAME$G,
+        methodName: METHOD_NAME$H,
         agentName: "",
         policyName: "",
         stateName: "",
@@ -13616,17 +13616,17 @@ const markOnline = async (clientId, swarmName) => {
     });
 };
 
-const METHOD_NAME$F = "function.other.markOffline";
+const METHOD_NAME$G = "function.other.markOffline";
 const markOffline = async (clientId, swarmName) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm.loggerService.log(METHOD_NAME$F, {
+        swarm.loggerService.log(METHOD_NAME$G, {
             clientId,
         });
-    swarm.swarmValidationService.validate(swarmName, METHOD_NAME$F);
+    swarm.swarmValidationService.validate(swarmName, METHOD_NAME$G);
     return await MethodContextService.runInContext(async () => {
-        await swarm.aliveService.markOffline(clientId, swarmName, METHOD_NAME$F);
+        await swarm.aliveService.markOffline(clientId, swarmName, METHOD_NAME$G);
     }, {
-        methodName: METHOD_NAME$F,
+        methodName: METHOD_NAME$G,
         agentName: "",
         policyName: "",
         stateName: "",
@@ -13636,7 +13636,7 @@ const markOffline = async (clientId, swarmName) => {
     });
 };
 
-const METHOD_NAME$E = "function.commit.commitToolOutput";
+const METHOD_NAME$F = "function.commit.commitToolOutput";
 /**
  * Commits the output of a tool execution to the active agent in a swarm session.
  *
@@ -13656,19 +13656,19 @@ const METHOD_NAME$E = "function.commit.commitToolOutput";
 const commitToolOutput = beginContext(async (toolId, content, clientId, agentName) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$E, {
+        swarm$1.loggerService.log(METHOD_NAME$F, {
             toolId,
             content,
             clientId,
             agentName,
         });
     // Validate the agent, session, and swarm to ensure they exist and are accessible
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$E);
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$E);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$F);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$F);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$E);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$F);
     // Check if the specified agent is still the active agent in the swarm session
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$E, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$F, clientId, swarmName);
     if (currentAgentName !== agentName) {
         // Log a skip message if the agent has changed during the operation
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
@@ -13681,11 +13681,11 @@ const commitToolOutput = beginContext(async (toolId, content, clientId, agentNam
         return;
     }
     // Commit the tool output to the session via the session public service
-    await swarm$1.sessionPublicService.commitToolOutput(toolId, content, METHOD_NAME$E, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitToolOutput(toolId, content, METHOD_NAME$F, clientId, swarmName);
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$D = "function.commit.commitSystemMessage";
+const METHOD_NAME$E = "function.commit.commitSystemMessage";
 /**
  * Commits a system-generated message to the active agent in the swarm system.
  * Validates the agent, session, and swarm, ensuring the current agent matches the provided agent before committing the message.
@@ -13704,20 +13704,20 @@ const METHOD_NAME$D = "function.commit.commitSystemMessage";
 const commitSystemMessage = beginContext(async (content, clientId, agentName) => {
     // Log the commit attempt if enabled
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$D, {
+        swarm$1.loggerService.log(METHOD_NAME$E, {
             content,
             clientId,
             agentName,
         });
     // Validate the agent exists
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$D);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$E);
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$D);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$E);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$D);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$E);
     // Check if the current agent matches the provided agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$D, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$E, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "commitSystemMessage" skipped due to the agent change', {
@@ -13728,11 +13728,11 @@ const commitSystemMessage = beginContext(async (content, clientId, agentName) =>
         return;
     }
     // Commit the system message via SessionPublicService
-    await swarm$1.sessionPublicService.commitSystemMessage(content, METHOD_NAME$D, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitSystemMessage(content, METHOD_NAME$E, clientId, swarmName);
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$C = "function.commit.commitFlush";
+const METHOD_NAME$D = "function.commit.commitFlush";
 /**
  * Commits a flush of agent history for a specific client and agent in the swarm system.
  * Validates the agent, session, and swarm, ensuring the current agent matches the provided agent before flushing the history.
@@ -13749,19 +13749,19 @@ const METHOD_NAME$C = "function.commit.commitFlush";
 const commitFlush = beginContext(async (clientId, agentName) => {
     // Log the flush attempt if enabled
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$C, {
+        swarm$1.loggerService.log(METHOD_NAME$D, {
             clientId,
             agentName,
         });
     // Validate the agent exists
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$C);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$D);
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$C);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$D);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$C);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$D);
     // Check if the current agent matches the provided agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$C, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$D, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "commitFlush" skipped due to the agent change', {
@@ -13772,10 +13772,10 @@ const commitFlush = beginContext(async (clientId, agentName) => {
         return;
     }
     // Commit the flush of agent history via SessionPublicService
-    await swarm$1.sessionPublicService.commitFlush(METHOD_NAME$C, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitFlush(METHOD_NAME$D, clientId, swarmName);
 });
 
-const METHOD_NAME$B = "function.commit.commitSystemMessage";
+const METHOD_NAME$C = "function.commit.commitSystemMessage";
 /**
  * Commits a user message to the active agent's history in a swarm session without triggering a response.
  *
@@ -13794,19 +13794,19 @@ const METHOD_NAME$B = "function.commit.commitSystemMessage";
 const commitUserMessage = beginContext(async (content, mode, clientId, agentName, payload) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$B, {
+        swarm$1.loggerService.log(METHOD_NAME$C, {
             content,
             clientId,
             agentName,
             mode,
         });
     // Validate the agent, session, and swarm to ensure they exist and are accessible
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$B);
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$B);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$C);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$C);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$B);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$C);
     // Check if the specified agent is still the active agent in the swarm session
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$B, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$C, clientId, swarmName);
     if (currentAgentName !== agentName) {
         // Log a skip message if the agent has changed during the operation
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
@@ -13819,17 +13819,17 @@ const commitUserMessage = beginContext(async (content, mode, clientId, agentName
     }
     if (payload) {
         return await PayloadContextService.runInContext(async () => {
-            await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$B, clientId, swarmName);
+            await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$C, clientId, swarmName);
         }, {
             clientId,
             payload,
         });
     }
     // Commit the user message to the agent's history via the session public service
-    return await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$B, clientId, swarmName);
+    return await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$C, clientId, swarmName);
 });
 
-const METHOD_NAME$A = "function.commit.commitToolOutputForce";
+const METHOD_NAME$B = "function.commit.commitToolOutputForce";
 /**
  * Commits the output of a tool execution to the active agent in a swarm session without checking the active agent.
  *
@@ -13848,21 +13848,21 @@ const METHOD_NAME$A = "function.commit.commitToolOutputForce";
 const commitToolOutputForce = beginContext(async (toolId, content, clientId) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$A, {
+        swarm$1.loggerService.log(METHOD_NAME$B, {
             toolId,
             content,
             clientId,
         });
     // Validate the session and swarm to ensure they exist and are accessible
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$A);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$B);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$A);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$B);
     // Commit the tool output to the session via the session public service without checking the active agent
-    await swarm$1.sessionPublicService.commitToolOutput(toolId, content, METHOD_NAME$A, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitToolOutput(toolId, content, METHOD_NAME$B, clientId, swarmName);
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$z = "function.commit.commitSystemMessageForce";
+const METHOD_NAME$A = "function.commit.commitSystemMessageForce";
 /**
  * Forcefully commits a system-generated message to a session in the swarm system, without checking the active agent.
  * Validates the session and swarm, then proceeds with committing the message regardless of the current agent state.
@@ -13881,21 +13881,21 @@ const METHOD_NAME$z = "function.commit.commitSystemMessageForce";
 const commitSystemMessageForce = beginContext(async (content, clientId) => {
     // Log the commit attempt if enabled
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$z, {
+        swarm$1.loggerService.log(METHOD_NAME$A, {
             content,
             clientId,
         });
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$z);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$A);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$z);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$A);
     // Commit the system message via SessionPublicService without agent checks
-    await swarm$1.sessionPublicService.commitSystemMessage(content, METHOD_NAME$z, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitSystemMessage(content, METHOD_NAME$A, clientId, swarmName);
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$y = "function.commit.commitFlushForce";
+const METHOD_NAME$z = "function.commit.commitFlushForce";
 /**
  * Forcefully commits a flush of agent history for a specific client in the swarm system, without checking the active agent.
  * Validates the session and swarm, then proceeds with flushing the history regardless of the current agent state.
@@ -13913,20 +13913,20 @@ const METHOD_NAME$y = "function.commit.commitFlushForce";
 const commitFlushForce = beginContext(async (clientId) => {
     // Log the flush attempt if enabled
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$y, {
+        swarm$1.loggerService.log(METHOD_NAME$z, {
             clientId,
-            METHOD_NAME: METHOD_NAME$y,
+            METHOD_NAME: METHOD_NAME$z,
         });
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$y);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$z);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$y);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$z);
     // Commit the flush of agent history via SessionPublicService without agent checks
-    await swarm$1.sessionPublicService.commitFlush(METHOD_NAME$y, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitFlush(METHOD_NAME$z, clientId, swarmName);
 });
 
-const METHOD_NAME$x = "function.commit.commitSystemMessage";
+const METHOD_NAME$y = "function.commit.commitSystemMessage";
 /**
  * Commits a user message to the active agent's history in a swarm session without triggering a response and without checking the active agent.
  *
@@ -13944,29 +13944,29 @@ const METHOD_NAME$x = "function.commit.commitSystemMessage";
 const commitUserMessageForce = beginContext(async (content, mode, clientId, payload) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$x, {
+        swarm$1.loggerService.log(METHOD_NAME$y, {
             content,
             clientId,
             mode,
         });
     // Validate the session and swarm to ensure they exist and are accessible
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$x);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$y);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$x);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$y);
     if (payload) {
         return await PayloadContextService.runInContext(async () => {
-            await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$x, clientId, swarmName);
+            await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$y, clientId, swarmName);
         }, {
             clientId,
             payload,
         });
     }
     // Commit the user message to the agent's history via the session public service without checking the active agent
-    return await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$x, clientId, swarmName);
+    return await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$y, clientId, swarmName);
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$w = "function.commit.commitAssistantMessage";
+const METHOD_NAME$x = "function.commit.commitAssistantMessage";
 /**
  * Commits an assistant-generated message to the active agent in the swarm system.
  * Validates the agent, session, and swarm, ensuring the current agent matches the provided agent before committing the message.
@@ -13984,20 +13984,20 @@ const METHOD_NAME$w = "function.commit.commitAssistantMessage";
 const commitAssistantMessage = beginContext(async (content, clientId, agentName) => {
     // Log the commit attempt if enabled
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$w, {
+        swarm$1.loggerService.log(METHOD_NAME$x, {
             content,
             clientId,
             agentName,
         });
     // Validate the agent exists
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$w);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$x);
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$w);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$x);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$w);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$x);
     // Check if the current agent matches the provided agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$w, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$x, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "commitAssistantMessage" skipped due to the agent change', {
@@ -14008,11 +14008,11 @@ const commitAssistantMessage = beginContext(async (content, clientId, agentName)
         return;
     }
     // Commit the assistant message via SessionPublicService
-    await swarm$1.sessionPublicService.commitAssistantMessage(content, METHOD_NAME$w, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitAssistantMessage(content, METHOD_NAME$x, clientId, swarmName);
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$v = "function.commit.commitAssistantMessageForce";
+const METHOD_NAME$w = "function.commit.commitAssistantMessageForce";
 /**
  * Forcefully commits an assistant-generated message to a session in the swarm system, without checking the active agent.
  * Validates the session and swarm, then proceeds with committing the message regardless of the current agent state.
@@ -14031,21 +14031,21 @@ const METHOD_NAME$v = "function.commit.commitAssistantMessageForce";
 const commitAssistantMessageForce = beginContext(async (content, clientId) => {
     // Log the commit attempt if enabled
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$v, {
+        swarm$1.loggerService.log(METHOD_NAME$w, {
             content,
             clientId,
         });
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$v);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$w);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$v);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$w);
     // Commit the assistant message via SessionPublicService without agent checks
-    await swarm$1.sessionPublicService.commitAssistantMessage(content, METHOD_NAME$v, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitAssistantMessage(content, METHOD_NAME$w, clientId, swarmName);
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$u = "function.commit.cancelOutput";
+const METHOD_NAME$v = "function.commit.cancelOutput";
 /**
  * Cancels the awaited output for a specific client and agent by emitting an empty string.
  * Validates the agent, session, and swarm, ensuring the current agent matches the provided agent before cancellation.
@@ -14061,19 +14061,19 @@ const METHOD_NAME$u = "function.commit.cancelOutput";
 const cancelOutput = beginContext(async (clientId, agentName) => {
     // Log the cancellation attempt if enabled
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$u, {
+        swarm$1.loggerService.log(METHOD_NAME$v, {
             clientId,
             agentName,
         });
     // Validate the agent exists
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$u);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$v);
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$u);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$v);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$u);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$v);
     // Check if the current agent matches the provided agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$u, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$v, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "cancelOutput" skipped due to the agent change', {
@@ -14084,11 +14084,11 @@ const cancelOutput = beginContext(async (clientId, agentName) => {
         return;
     }
     // Perform the output cancellation via SwarmPublicService
-    await swarm$1.swarmPublicService.cancelOutput(METHOD_NAME$u, clientId, swarmName);
+    await swarm$1.swarmPublicService.cancelOutput(METHOD_NAME$v, clientId, swarmName);
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$t = "function.commit.cancelOutputForce";
+const METHOD_NAME$u = "function.commit.cancelOutputForce";
 /**
  * Forcefully cancels the awaited output for a specific client by emitting an empty string, without checking the active agent.
  * Validates the session and swarm, then proceeds with cancellation regardless of the current agent state.
@@ -14105,20 +14105,20 @@ const METHOD_NAME$t = "function.commit.cancelOutputForce";
 const cancelOutputForce = beginContext(async (clientId) => {
     // Log the cancellation attempt if enabled
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$t, {
+        swarm$1.loggerService.log(METHOD_NAME$u, {
             clientId,
         });
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$t);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$u);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$t);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$u);
     // Perform the output cancellation via SwarmPublicService without agent checks
-    await swarm$1.swarmPublicService.cancelOutput(METHOD_NAME$t, clientId, swarmName);
+    await swarm$1.swarmPublicService.cancelOutput(METHOD_NAME$u, clientId, swarmName);
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$s = "function.commit.commitStopTools";
+const METHOD_NAME$t = "function.commit.commitStopTools";
 /**
  * Prevents the next tool from being executed for a specific client and agent in the swarm system.
  * Validates the agent, session, and swarm, ensuring the current agent matches the provided agent before stopping tool execution.
@@ -14135,19 +14135,19 @@ const METHOD_NAME$s = "function.commit.commitStopTools";
 const commitStopTools = beginContext(async (clientId, agentName) => {
     // Log the stop tools attempt if enabled
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$s, {
+        swarm$1.loggerService.log(METHOD_NAME$t, {
             clientId,
             agentName,
         });
     // Validate the agent exists
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$s);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$t);
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$s);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$t);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$s);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$t);
     // Check if the current agent matches the provided agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$s, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$t, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "commitStopTools" skipped due to the agent change', {
@@ -14158,11 +14158,11 @@ const commitStopTools = beginContext(async (clientId, agentName) => {
         return;
     }
     // Commit the stop of the next tool execution via SessionPublicService
-    await swarm$1.sessionPublicService.commitStopTools(METHOD_NAME$s, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitStopTools(METHOD_NAME$t, clientId, swarmName);
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$r = "function.commit.commitStopToolsForce";
+const METHOD_NAME$s = "function.commit.commitStopToolsForce";
 /**
  * Forcefully prevents the next tool from being executed for a specific client in the swarm system, without checking the active agent.
  * Validates the session and swarm, then proceeds with stopping tool execution regardless of the current agent state.
@@ -14180,20 +14180,20 @@ const METHOD_NAME$r = "function.commit.commitStopToolsForce";
 const commitStopToolsForce = beginContext(async (clientId) => {
     // Log the stop tools attempt if enabled
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$r, {
+        swarm$1.loggerService.log(METHOD_NAME$s, {
             clientId,
-            METHOD_NAME: METHOD_NAME$r,
+            METHOD_NAME: METHOD_NAME$s,
         });
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$r);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$s);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$r);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$s);
     // Commit the stop of the next tool execution via SessionPublicService without agent checks
-    await swarm$1.sessionPublicService.commitStopTools(METHOD_NAME$r, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitStopTools(METHOD_NAME$s, clientId, swarmName);
 });
 
-const METHOD_NAME$q = "function.target.emitForce";
+const METHOD_NAME$r = "function.target.emitForce";
 /**
  * Emits a string as model output without executing an incoming message or checking the active agent.
  *
@@ -14212,19 +14212,19 @@ const METHOD_NAME$q = "function.target.emitForce";
 const emitForce = beginContext(async (content, clientId) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$q, {
+        swarm$1.loggerService.log(METHOD_NAME$r, {
             content,
             clientId,
         });
     // Validate the session and swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$q);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$r);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$q);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$r);
     // Emit the content directly via the session public service
-    return await swarm$1.sessionPublicService.emit(content, METHOD_NAME$q, clientId, swarmName);
+    return await swarm$1.sessionPublicService.emit(content, METHOD_NAME$r, clientId, swarmName);
 });
 
-const METHOD_NAME$p = "function.target.executeForce";
+const METHOD_NAME$q = "function.target.executeForce";
 /**
  * Sends a message to the active agent in a swarm session as if it originated from the client side, forcing execution regardless of agent activity.
  *
@@ -14245,22 +14245,22 @@ const executeForce = beginContext(async (content, clientId) => {
     const executionId = functoolsKit.randomString();
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$p, {
+        swarm$1.loggerService.log(METHOD_NAME$q, {
             content,
             clientId,
             executionId,
         });
     // Validate the session and swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$p);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$q);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$p);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$q);
     // Execute the command within an execution context with performance tracking
     return ExecutionContextService.runInContext(async () => {
         let isFinished = false;
         swarm$1.perfService.startExecution(executionId, clientId, content.length);
         try {
             swarm$1.busService.commitExecutionBegin(clientId, { swarmName });
-            const result = await swarm$1.sessionPublicService.execute(content, "tool", METHOD_NAME$p, clientId, swarmName);
+            const result = await swarm$1.sessionPublicService.execute(content, "tool", METHOD_NAME$q, clientId, swarmName);
             isFinished = swarm$1.perfService.endExecution(executionId, clientId, result.length);
             swarm$1.busService.commitExecutionEnd(clientId, { swarmName });
             return result;
@@ -14277,7 +14277,7 @@ const executeForce = beginContext(async (content, clientId) => {
     });
 });
 
-const METHOD_NAME$o = "function.target.disposeConnection";
+const METHOD_NAME$p = "function.target.disposeConnection";
 /**
  * Disposes of a client session and all related resources within a swarm.
  *
@@ -14294,10 +14294,10 @@ const METHOD_NAME$o = "function.target.disposeConnection";
  * @example
  * await disposeConnection("client-123", "TaskSwarm");
  */
-const disposeConnection = beginContext(async (clientId, swarmName, methodName = METHOD_NAME$o) => {
+const disposeConnection = beginContext(async (clientId, swarmName, methodName = METHOD_NAME$p) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$o, {
+        swarm$1.loggerService.log(METHOD_NAME$p, {
             clientId,
             swarmName,
         });
@@ -14366,7 +14366,7 @@ const disposeConnection = beginContext(async (clientId, swarmName, methodName =
     PersistMemoryAdapter.dispose(clientId);
 });
 
-const METHOD_NAME$n = "function.target.makeAutoDispose";
+const METHOD_NAME$o = "function.target.makeAutoDispose";
 /**
  * Default timeout in seconds before auto-dispose is triggered.
  * @constant {number}
@@ -14397,7 +14397,7 @@ const DEFAULT_TIMEOUT = 15 * 60;
 const makeAutoDispose = beginContext((clientId, swarmName, { timeoutSeconds = DEFAULT_TIMEOUT, onDestroy, } = {}) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$n, {
+        swarm$1.loggerService.log(METHOD_NAME$o, {
             clientId,
             swarmName,
         });
@@ -14430,7 +14430,7 @@ const makeAutoDispose = beginContext((clientId, swarmName, { timeoutSeconds = DE
     };
 });
 
-const METHOD_NAME$m = "function.target.execute";
+const METHOD_NAME$n = "function.target.execute";
 /**
  * Sends a message to the active agent in a swarm session as if it originated from the client side.
  *
@@ -14452,19 +14452,19 @@ const execute = beginContext(async (content, clientId, agentName) => {
     const executionId = functoolsKit.randomString();
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$m, {
+        swarm$1.loggerService.log(METHOD_NAME$n, {
             content,
             clientId,
             agentName,
             executionId,
         });
     // Validate the agent, session, and swarm
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$m);
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$m);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$n);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$n);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$m);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$n);
     // Check if the specified agent is still the active agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$m, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$n, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "execute" skipped due to the agent change', {
@@ -14483,7 +14483,7 @@ const execute = beginContext(async (content, clientId, agentName) => {
                 agentName,
                 swarmName,
             });
-            const result = await swarm$1.sessionPublicService.execute(content, "tool", METHOD_NAME$m, clientId, swarmName);
+            const result = await swarm$1.sessionPublicService.execute(content, "tool", METHOD_NAME$n, clientId, swarmName);
             isFinished = swarm$1.perfService.endExecution(executionId, clientId, result.length);
             swarm$1.busService.commitExecutionEnd(clientId, {
                 agentName,
@@ -14503,7 +14503,7 @@ const execute = beginContext(async (content, clientId, agentName) => {
     });
 });
 
-const METHOD_NAME$l = "function.target.emit";
+const METHOD_NAME$m = "function.target.emit";
 /**
  * Emits a string as model output without executing an incoming message, with agent activity validation.
  *
@@ -14523,18 +14523,18 @@ const METHOD_NAME$l = "function.target.emit";
 const emit = beginContext(async (content, clientId, agentName) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$l, {
+        swarm$1.loggerService.log(METHOD_NAME$m, {
             content,
             clientId,
             agentName,
         });
     // Validate the agent, session, and swarm
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$l);
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$l);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$m);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$m);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$l);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$m);
     // Check if the specified agent is still the active agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$l, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$m, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "emit" skipped due to the agent change', {
@@ -14545,10 +14545,10 @@ const emit = beginContext(async (content, clientId, agentName) => {
         return;
     }
     // Emit the content directly via the session public service
-    return await swarm$1.sessionPublicService.emit(content, METHOD_NAME$l, clientId, swarmName);
+    return await swarm$1.sessionPublicService.emit(content, METHOD_NAME$m, clientId, swarmName);
 });
 
-const METHOD_NAME$k = "function.target.runStateless";
+const METHOD_NAME$l = "function.target.runStateless";
 /**
  * Executes a message statelessly with an agent in a swarm session, bypassing chat history.
  *
@@ -14571,19 +14571,19 @@ const runStateless = beginContext(async (content, clientId, agentName) => {
     const executionId = functoolsKit.randomString();
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$k, {
+        swarm$1.loggerService.log(METHOD_NAME$l, {
             content,
             clientId,
             agentName,
             executionId,
         });
     // Validate the agent, session, and swarm
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$k);
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$k);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$l);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$l);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$k);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$l);
     // Check if the specified agent is still the active agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$k, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$l, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "runStateless" skipped due to the agent change', {
@@ -14602,7 +14602,7 @@ const runStateless = beginContext(async (content, clientId, agentName) => {
                 agentName,
                 swarmName,
             });
-            const result = await swarm$1.sessionPublicService.run(content, METHOD_NAME$k, clientId, swarmName);
+            const result = await swarm$1.sessionPublicService.run(content, METHOD_NAME$l, clientId, swarmName);
             isFinished = swarm$1.perfService.endExecution(executionId, clientId, result.length);
             swarm$1.busService.commitExecutionEnd(clientId, {
                 agentName,
@@ -14622,7 +14622,7 @@ const runStateless = beginContext(async (content, clientId, agentName) => {
     });
 });
 
-const METHOD_NAME$j = "function.target.runStatelessForce";
+const METHOD_NAME$k = "function.target.runStatelessForce";
 /**
  * Executes a message statelessly with the active agent in a swarm session, bypassing chat history and forcing execution regardless of agent activity.
  *
@@ -14643,22 +14643,22 @@ const runStatelessForce = beginContext(async (content, clientId) => {
     const executionId = functoolsKit.randomString();
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$j, {
+        swarm$1.loggerService.log(METHOD_NAME$k, {
             content,
             clientId,
             executionId,
         });
     // Validate the session and swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$j);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$k);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$j);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$k);
     // Execute the command statelessly within an execution context with performance tracking
     return ExecutionContextService.runInContext(async () => {
         let isFinished = false;
         swarm$1.perfService.startExecution(executionId, clientId, content.length);
         try {
             swarm$1.busService.commitExecutionBegin(clientId, { swarmName });
-            const result = await swarm$1.sessionPublicService.run(content, METHOD_NAME$j, clientId, swarmName);
+            const result = await swarm$1.sessionPublicService.run(content, METHOD_NAME$k, clientId, swarmName);
             isFinished = swarm$1.perfService.endExecution(executionId, clientId, result.length);
             swarm$1.busService.commitExecutionEnd(clientId, { swarmName });
             return result;
@@ -14685,7 +14685,7 @@ const SCHEDULED_DELAY$1 = 1000;
  * @constant {number}
  */
 const RATE_DELAY = 10000;
-const METHOD_NAME$i = "function.target.makeConnection";
+const METHOD_NAME$j = "function.target.makeConnection";
 /**
  * Internal implementation of the connection factory for a client to a swarm.
  *
@@ -14700,21 +14700,21 @@ const METHOD_NAME$i = "function.target.makeConnection";
 const makeConnectionInternal = (connector, clientId, swarmName) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$i, {
+        swarm$1.loggerService.log(METHOD_NAME$j, {
             clientId,
             swarmName,
         });
     // Validate the swarm and initialize the session
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$i);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$j);
     swarm$1.sessionValidationService.addSession(clientId, swarmName, "makeConnection");
     // Create a queued send function using the session public service
-    const send = functoolsKit.queued(swarm$1.sessionPublicService.connect(connector, METHOD_NAME$i, clientId, swarmName));
+    const send = functoolsKit.queued(swarm$1.sessionPublicService.connect(connector, METHOD_NAME$j, clientId, swarmName));
     // Return a wrapped send function with validation and agent context
     return (async (outgoing) => {
-        swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$i);
+        swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$j);
         return await send({
             data: outgoing,
-            agentName: await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$i, clientId, swarmName),
+            agentName: await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$j, clientId, swarmName),
             clientId,
         });
     });
@@ -14797,13 +14797,13 @@ makeConnection.scheduled = (connector, clientId, swarmName, { delay = SCHEDULED_
             await online();
             if (payload) {
                 return await PayloadContextService.runInContext(async () => {
-                    await swarm$1.sessionPublicService.commitUserMessage(content, "user", METHOD_NAME$i, clientId, swarmName);
+                    await swarm$1.sessionPublicService.commitUserMessage(content, "user", METHOD_NAME$j, clientId, swarmName);
                 }, {
                     clientId,
                     payload,
                 });
             }
-            await swarm$1.sessionPublicService.commitUserMessage(content, "user", METHOD_NAME$i, clientId, swarmName);
+            await swarm$1.sessionPublicService.commitUserMessage(content, "user", METHOD_NAME$j, clientId, swarmName);
         }),
         delay,
     });
@@ -14866,7 +14866,7 @@ makeConnection.rate = (connector, clientId, swarmName, { delay = RATE_DELAY } =
     };
 };
 
-const METHOD_NAME$h = "function.target.complete";
+const METHOD_NAME$i = "function.target.complete";
 /**
  * Time-to-live for the complete function in milliseconds.
  * Defines how long the cached complete function remains valid before expiring.
@@ -14932,7 +14932,7 @@ const complete = beginContext(async (content, clientId, swarmName, payload = nul
     const executionId = functoolsKit.randomString();
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$h, {
+        swarm$1.loggerService.log(METHOD_NAME$i, {
             content,
             clientId,
             executionId,
@@ -14949,7 +14949,7 @@ const complete = beginContext(async (content, clientId, swarmName, payload = nul
             swarm$1.perfService.startExecution(executionId, clientId, content.length);
             try {
                 swarm$1.busService.commitExecutionBegin(clientId, { swarmName });
-                const result = await run(METHOD_NAME$h, content);
+                const result = await run(METHOD_NAME$i, content);
                 isFinished = swarm$1.perfService.endExecution(executionId, clientId, result.length);
                 swarm$1.busService.commitExecutionEnd(clientId, { swarmName });
                 return result;
@@ -14979,7 +14979,7 @@ const complete = beginContext(async (content, clientId, swarmName, payload = nul
  * @constant {number}
  */
 const SCHEDULED_DELAY = 1000;
-const METHOD_NAME$g = "function.target.session";
+const METHOD_NAME$h = "function.target.session";
 /**
  * Internal implementation of the session factory for a client and swarm.
  *
@@ -14994,22 +14994,22 @@ const sessionInternal = (clientId, swarmName, { onDispose = () => { } } = {}) =>
     const executionId = functoolsKit.randomString();
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$g, {
+        swarm$1.loggerService.log(METHOD_NAME$h, {
             clientId,
             swarmName,
             executionId,
         });
     // Validate the swarm and initialize the session
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$g);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$h);
     swarm$1.sessionValidationService.addSession(clientId, swarmName, "session");
     const complete = functoolsKit.queued(async (content) => {
-        swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$g);
+        swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$h);
         return ExecutionContextService.runInContext(async () => {
             let isFinished = false;
             swarm$1.perfService.startExecution(executionId, clientId, content.length);
             try {
                 swarm$1.busService.commitExecutionBegin(clientId, { swarmName });
-                const result = await swarm$1.sessionPublicService.execute(content, "user", METHOD_NAME$g, clientId, swarmName);
+                const result = await swarm$1.sessionPublicService.execute(content, "user", METHOD_NAME$h, clientId, swarmName);
                 isFinished = swarm$1.perfService.endExecution(executionId, clientId, result.length);
                 swarm$1.busService.commitExecutionEnd(clientId, { swarmName });
                 return result;
@@ -15030,7 +15030,7 @@ const sessionInternal = (clientId, swarmName, { onDispose = () => { } } = {}) =>
             return await complete(content);
         }),
         dispose: async () => {
-            await disposeConnection(clientId, swarmName, METHOD_NAME$g);
+            await disposeConnection(clientId, swarmName, METHOD_NAME$h);
             await onDispose();
         },
     };
@@ -15130,13 +15130,13 @@ session.scheduled = (clientId, swarmName, { delay = SCHEDULED_DELAY, onDispose }
             await online();
             if (payload) {
                 return await PayloadContextService.runInContext(async () => {
-                    return await swarm$1.sessionPublicService.commitUserMessage(content, "user", METHOD_NAME$g, clientId, swarmName);
+                    return await swarm$1.sessionPublicService.commitUserMessage(content, "user", METHOD_NAME$h, clientId, swarmName);
                 }, {
                     clientId,
                     payload,
                 });
             }
-            return await swarm$1.sessionPublicService.commitUserMessage(content, "user", METHOD_NAME$g, clientId, swarmName);
+            return await swarm$1.sessionPublicService.commitUserMessage(content, "user", METHOD_NAME$h, clientId, swarmName);
         }),
         delay,
     });
@@ -15215,6 +15215,22 @@ session.rate = (clientId, swarmName, { delay = SCHEDULED_DELAY, onDispose } = {}
     };
 };
 
+/** @private Constant defining the method name for logging purposes */
+const METHOD_NAME$g = "function.common.hasSession";
+/**
+ * Checks if a session exists for the given client ID.
+ *
+ * This function logs the method name if logging is enabled in the global configuration.
+ * It then delegates the session validation to the `swarm.sessionValidationService`.
+ *
+ * @param {string} clientId - The unique identifier of the client whose session is being validated.
+ * @returns {boolean} `true` if the session exists, otherwise `false`.
+ */
+const hasSession = (clientId) => {
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$g);
+    return swarm$1.sessionValidationService.hasSession(clientId);
+};
+
 const METHOD_NAME$f = "function.common.getAgentName";
 /**
  * Retrieves the name of the active agent for a given client session in a swarm.
@@ -16862,140 +16878,137 @@ class SharedStateUtils {
  */
 const SharedState = new SharedStateUtils();
 
-/** @constant {string} Method name for beginning a chat in ChatUtils */
-const CHAT_UTILS_METHOD_NAME_BEGIN_CHAT = "ChatUtils.beginChat";
-/** @constant {string} Method name for sending a message in ChatUtils */
-const CHAT_UTILS_METHOD_NAME_SEND_MESSAGE = "ChatUtils.sendMessage";
-/** @constant {string} Method name for listening to dispose events in ChatUtils */
-const CHAT_UTILS_METHOD_NAME_LISTEN_DISPOSE = "ChatUtils.listenDispose";
-/** @constant {string} Method name for disposing a chat in ChatUtils */
-const CHAT_UTILS_METHOD_NAME_DISPOSE = "ChatUtils.dispose";
-/** @constant {string} Method name for beginning a chat in ChatInstance */
-const CHAT_INSTANCE_METHOD_NAME_BEGIN_CHAT = "ChatInstance.beginChat";
-/** @constant {string} Method name for sending a message in ChatInstance */
-const CHAT_INSTANCE_METHOD_NAME_SEND_MESSAGE = "ChatInstance.sendMessage";
-/** @constant {string} Method name for disposing a chat in ChatInstance */
-const CHAT_INSTANCE_METHOD_NAME_DISPOSE = "ChatInstance.dispose";
-/** @constant {string} Method name for listening to dispose events in ChatInstance */
-const CHAT_INSTANCE_METHOD_NAME_LISTEN_DISPOSE = "ChatInstance.listenDispose";
-/** @constant {number} Time interval in milliseconds for inactivity checks (1 minute) */
+/** @constant {number} INACTIVITY_CHECK - Interval for checking inactivity in milliseconds (1 minute) */
 const INACTIVITY_CHECK = 60 * 1000;
-/** @constant {number} Time in milliseconds before a chat is considered inactive (15 minutes) */
+/** @constant {number} INACTIVITY_TIMEOUT - Timeout duration for inactivity in milliseconds (15 minutes) */
 const INACTIVITY_TIMEOUT = 15 * 60 * 1000;
 /**
- * Represents a single chat instance for a client
- * @class
+ * @class ChatInstance
+ * @implements {IChatInstance}
+ * @description Implementation of a single chat instance
  */
 class ChatInstance {
     /**
-     * Gets the timestamp of the last activity
-     * @public
-     * @returns {number} Last activity timestamp in milliseconds
-     */
-    get lastActivity() {
-        return this._lastActivity;
-    }
-    /**
-     * Creates a new ChatInstance
      * @constructor
-     * @param {SessionId} clientId - Unique identifier for the client
-     * @param {SwarmName} swarmName - Name of the swarm this chat belongs to
-     * @param {DisposeFn} onDispose - Callback function executed when chat is disposed
+     * @param {SessionId} clientId - Unique client identifier
+     * @param {SwarmName} swarmName - Name of the swarm
+     * @param {Partial<IChatInstanceCallbacks>} callbacks - Event callbacks
+     * @param {DisposeFn} onDispose - Dispose callback function
      */
-    constructor(clientId, swarmName, onDispose) {
+    constructor(clientId, swarmName, onDispose, callbacks) {
         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.callbacks = callbacks;
+        /** @private */
+        this._disposeSubject = new functoolsKit.Subject();
+        /** @private */
         this._lastActivity = Date.now();
-        /**
-         * Initiates the chat session
-         * @public
-         * @async
-         * @returns {Promise<void>} Promise that resolves when chat is initiated
-         */
-        this.beginChat = () => {
-            GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
-                swarm$1.loggerService.debug(CHAT_INSTANCE_METHOD_NAME_BEGIN_CHAT, {
-                    clientId: this.clientId,
-                    swarmName: this.swarmName,
-                    timestamp: new Date().toISOString(),
-                });
-            return Promise.resolve();
-        };
-        /**
-         * Sends a message through the chat session
-         * @public
-         * @async
-         * @param {string} content - The 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 and cleans up resources
-         * @public
-         * @async
-         * @returns {Promise<void>} Promise that resolves when disposal is complete
-         */
-        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 for this chat instance
-         * @public
-         * @param {(clientId: SessionId) => void} fn - Callback function to execute on disposal
-         * @returns {any} Subscription object for managing the subscription
-         */
-        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, {
+        GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
+            swarm$1.loggerService.debug("ChatInstance CTOR", {
+                clientId: this.clientId,
+                swarmName: this.swarmName,
+            });
+        this._chatSession = session(this.clientId, this.swarmName, {
             onDispose: this.onDispose,
         });
+        this.callbacks.onInit &&
+            this.callbacks.onInit(this.clientId, this.swarmName, this);
+    }
+    /**
+     * Checks if the chat has been active within the timeout period
+     * @param {number} now - Current timestamp
+     * @returns {boolean} Whether the chat is still active
+     */
+    async checkLastActivity(now) {
+        GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
+            swarm$1.loggerService.debug("ChatInstance.checkLastActivity", {
+                clientId: this.clientId,
+                swarmName: this.swarmName,
+            });
+        const isActive = now - this._lastActivity <= INACTIVITY_TIMEOUT;
+        this.callbacks.onCheckActivity &&
+            this.callbacks.onCheckActivity(this.clientId, this.swarmName, isActive, this._lastActivity);
+        return isActive;
+    }
+    /**
+     * Begins a chat session
+     * @returns {Promise<void>}
+     */
+    beginChat() {
+        GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
+            swarm$1.loggerService.debug("ChatInstance.beginChat", {
+                clientId: this.clientId,
+                swarmName: this.swarmName,
+            });
+        this.callbacks.onBeginChat &&
+            this.callbacks.onBeginChat(this.clientId, this.swarmName);
+        return Promise.resolve();
+    }
+    /**
+     * Sends a message in the chat
+     * @param {string} content - Message content to send
+     * @returns {Promise<string>} Response from the chat session
+     */
+    async sendMessage(content) {
+        GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
+            swarm$1.loggerService.debug("ChatInstance.sendMessage", {
+                content,
+                clientId: this.clientId,
+                swarmName: this.swarmName,
+            });
+        this._lastActivity = Date.now();
+        this.callbacks.onSendMessage &&
+            this.callbacks.onSendMessage(this.clientId, this.swarmName, content);
+        return await this._chatSession.complete(content);
+    }
+    /**
+     * Disposes of the chat instance
+     * @returns {Promise<void>}
+     */
+    async dispose() {
+        GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
+            swarm$1.loggerService.debug("ChatInstance.dispose", {
+                clientId: this.clientId,
+                swarmName: this.swarmName,
+            });
+        await this._disposeSubject.next(this.clientId);
+        await this._chatSession.dispose();
+        this.callbacks.onDispose &&
+            this.callbacks.onDispose(this.clientId, this.swarmName, this);
+    }
+    /**
+     * Adds a listener for dispose events
+     * @param {(clientId: SessionId) => void} fn - Callback function to execute on dispose
+     */
+    listenDispose(fn) {
+        GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
+            swarm$1.loggerService.debug("ChatInstance.listenDispose", {
+                clientId: this.clientId,
+                swarmName: this.swarmName,
+            });
+        return this._disposeSubject.once(fn);
     }
 }
 /**
- * Utility class for managing multiple chat instances
- * @class
+ * @class ChatUtils
+ * @implements {IChatControl}
+ * @description Utility class for managing multiple chat instances
  */
 class ChatUtils {
     constructor() {
-        /** @private @type {Map<SessionId, ChatInstance>} Map of active chat instances */
+        /** @private */
+        this.ChatInstanceFactory = ChatInstance;
+        /** @private */
+        this.ChatInstanceCallbacks = {};
+        /** @private */
         this._chats = new Map();
-        /**
-         * Initializes cleanup interval for inactive chats
-         * @private
-         * @returns {void}
-         */
+        /** @private */
         this.initializeCleanup = functoolsKit.singleshot(() => {
             const handleCleanup = async () => {
                 const now = Date.now();
                 for (const chat of this._chats.values()) {
-                    if (now - chat.lastActivity >= INACTIVITY_TIMEOUT) {
+                    if (!chat.checkLastActivity(now)) {
                         await chat.dispose();
                     }
                 }
@@ -17005,30 +17018,31 @@ class ChatUtils {
         /**
          * Gets or creates a chat instance for a client
          * @private
-         * @param {SessionId} clientId - Unique identifier for the client
+         * @param {SessionId} clientId - Unique client identifier
          * @param {SwarmName} swarmName - Name of the swarm
-         * @returns {ChatInstance} Existing or new chat instance for the client
+         * @returns {IChatInstance} The chat instance for the given 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);
-                }))
+                    .set(clientId, Reflect.construct(this.ChatInstanceFactory, [
+                    clientId,
+                    swarmName,
+                    () => this._chats.delete(clientId),
+                    this.ChatInstanceCallbacks,
+                ]))
                     .get(clientId);
         };
         /**
          * Begins a chat session for a client
-         * @public
-         * @async
-         * @param {SessionId} clientId - Unique identifier for the client
+         * @param {SessionId} clientId - Unique client identifier
          * @param {SwarmName} swarmName - Name of the swarm
-         * @returns {Promise<void>} Promise that resolves when chat begins
+         * @returns {Promise<void>}
          */
         this.beginChat = async (clientId, swarmName) => {
             GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                swarm$1.loggerService.log(CHAT_UTILS_METHOD_NAME_BEGIN_CHAT, {
+                swarm$1.loggerService.log("ChatUtils.beginChat", {
                     clientId,
                     swarmName,
                 });
@@ -17036,17 +17050,15 @@ class ChatUtils {
             return await this.getChatInstance(clientId, swarmName).beginChat();
         };
         /**
-         * Sends a message for a specific client
-         * @public
-         * @async
-         * @param {SessionId} clientId - Unique identifier for the client
-         * @param {string} message - Message content to send
+         * Sends a message for a client
+         * @param {SessionId} clientId - Unique client identifier
+         * @param {string} message - Message content
          * @param {SwarmName} swarmName - Name of the swarm
-         * @returns {Promise<any>} Result of the message sending operation
+         * @returns {Promise<string>}
          */
         this.sendMessage = async (clientId, message, swarmName) => {
             GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                swarm$1.loggerService.log(CHAT_UTILS_METHOD_NAME_SEND_MESSAGE, {
+                swarm$1.loggerService.log("ChatUtils.sendMessage", {
                     clientId,
                     message,
                     swarmName,
@@ -17055,32 +17067,28 @@ class ChatUtils {
             return await this.getChatInstance(clientId, swarmName).sendMessage(message);
         };
         /**
-         * Subscribes to disposal events for a specific client's chat
-         * @public
-         * @param {SessionId} clientId - Unique identifier for the client
+         * Listens for dispose events for a client
+         * @param {SessionId} clientId - Unique client identifier
          * @param {SwarmName} swarmName - Name of the swarm
-         * @param {(clientId: SessionId) => void} fn - Callback function for disposal events
-         * @returns {any} Subscription object for managing the subscription
+         * @param {(clientId: SessionId) => void} fn - Dispose callback
          */
         this.listenDispose = (clientId, swarmName, fn) => {
             GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                swarm$1.loggerService.log(CHAT_UTILS_METHOD_NAME_LISTEN_DISPOSE, {
+                swarm$1.loggerService.log("ChatUtils.listenDispose", {
                     clientId,
                     swarmName,
                 });
             return this.getChatInstance(clientId, swarmName).listenDispose(fn);
         };
         /**
-         * Disposes of a specific chat instance for a client
-         * @public
-         * @async
-         * @param {SessionId} clientId - Unique identifier for the client
+         * Disposes of a chat instance
+         * @param {SessionId} clientId - Unique client identifier
          * @param {SwarmName} swarmName - Name of the swarm
-         * @returns {Promise<void>} Promise that resolves when disposal is complete
+         * @returns {Promise<void>}
          */
         this.dispose = async (clientId, swarmName) => {
             GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                swarm$1.loggerService.log(CHAT_UTILS_METHOD_NAME_DISPOSE, {
+                swarm$1.loggerService.log("ChatUtils.dispose", {
                     clientId,
                     swarmName,
                 });
@@ -17090,8 +17098,29 @@ class ChatUtils {
             return await this.getChatInstance(clientId, swarmName).dispose();
         };
     }
+    /**
+     * Sets the chat instance constructor
+     * @param {TChatInstanceCtor} Ctor - Chat instance constructor
+     */
+    useChatAdapter(Ctor) {
+        GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
+            swarm$1.loggerService.log("ChatUtils.useChatAdapter");
+        this.ChatInstanceFactory = Ctor;
+    }
+    /**
+     * Sets chat instance callbacks
+     * @param {Partial<IChatInstanceCallbacks>} Callbacks - Callback implementations
+     */
+    useChatCallbacks(Callbacks) {
+        GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
+            swarm$1.loggerService.log("ChatUtils.useChatCallbacks");
+        Object.assign(this.ChatInstanceCallbacks, Callbacks);
+    }
 }
-/** @constant {ChatUtils} Singleton instance of ChatUtils for application-wide use */
+/**
+ * @constant {ChatUtils} Chat
+ * @description Singleton instance of ChatUtils
+ */
 const Chat = new ChatUtils();
 
 /** @private Constant for logging the take method in StorageUtils */
@@ -17953,6 +17982,7 @@ exports.getRawHistory = getRawHistory;
 exports.getSessionContext = getSessionContext;
 exports.getSessionMode = getSessionMode;
 exports.getUserHistory = getUserHistory;
+exports.hasSession = hasSession;
 exports.listenAgentEvent = listenAgentEvent;
 exports.listenAgentEventOnce = listenAgentEventOnce;
 exports.listenEvent = listenEvent;