agent-swarm-kit 1.0.169 → 1.0.170

package/build/index.cjs

@@ -39,6 +39,7 @@ const baseServices$1 = {
 };
 const contextServices$1 = {
     methodContextService: Symbol('methodContextService'),
+    payloadContextService: Symbol('payloadContextService'),
     executionContextService: Symbol('executionContextService'),
 };
 const connectionServices$1 = {
@@ -12458,6 +12459,21 @@ class PolicyConnectionService {
     }
 }
 
+/**
+ * A scoped service class that encapsulates a payload context for dependency injection.
+ * Provides a way to access execution metadata and payload data within a specific scope.
+ * Scoped using `di-scoped` to ensure instance isolation per scope.
+ */
+const PayloadContextService = diScoped.scoped(class {
+    /**
+     * Creates a new instance of PayloadContextService with the provided context.
+     * @param context - The payload context containing client, execution, process IDs, and payload data.
+     */
+    constructor(context) {
+        this.context = context;
+    }
+});
+
 {
     provide(TYPES.docService, () => new DocService());
     provide(TYPES.busService, () => new BusService());
@@ -12466,6 +12482,7 @@ class PolicyConnectionService {
 }
 {
     provide(TYPES.methodContextService, () => new MethodContextService());
+    provide(TYPES.payloadContextService, () => new PayloadContextService());
     provide(TYPES.executionContextService, () => new ExecutionContextService());
 }
 {
@@ -12524,6 +12541,7 @@ const baseServices = {
 };
 const contextServices = {
     methodContextService: inject(TYPES.methodContextService),
+    payloadContextService: inject(TYPES.payloadContextService),
     executionContextService: inject(TYPES.executionContextService),
 };
 const connectionServices = {
@@ -12585,7 +12603,7 @@ const swarm = {
 init();
 var swarm$1 = swarm;
 
-const METHOD_NAME$R = "cli.dumpDocs";
+const METHOD_NAME$S = "cli.dumpDocs";
 /**
  * Dumps the documentation for the agents and swarms.
  *
@@ -12595,7 +12613,7 @@ const METHOD_NAME$R = "cli.dumpDocs";
  */
 const dumpDocs = beginContext((dirName = "./docs/chat", PlantUML) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$R, {
+        swarm$1.loggerService.log(METHOD_NAME$S, {
             dirName,
         });
     if (PlantUML) {
@@ -12605,10 +12623,10 @@ const dumpDocs = beginContext((dirName = "./docs/chat", PlantUML) => {
     }
     swarm$1.agentValidationService
         .getAgentList()
-        .forEach((agentName) => swarm$1.agentValidationService.validate(agentName, METHOD_NAME$R));
+        .forEach((agentName) => swarm$1.agentValidationService.validate(agentName, METHOD_NAME$S));
     swarm$1.swarmValidationService
         .getSwarmList()
-        .forEach((swarmName) => swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$R));
+        .forEach((swarmName) => swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$S));
     swarm$1.agentValidationService.getAgentList().forEach((agentName) => {
         const { dependsOn } = swarm$1.agentSchemaService.get(agentName);
         if (!dependsOn) {
@@ -12618,7 +12636,7 @@ const dumpDocs = beginContext((dirName = "./docs/chat", PlantUML) => {
     return swarm$1.docService.dumpDocs(dirName);
 });
 
-const METHOD_NAME$Q = "cli.dumpAgent";
+const METHOD_NAME$R = "cli.dumpAgent";
 /**
  * Dumps the agent information into PlantUML format.
  *
@@ -12627,14 +12645,14 @@ const METHOD_NAME$Q = "cli.dumpAgent";
  */
 const dumpAgent = beginContext((agentName, { withSubtree = false } = {}) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$Q, {
+        swarm$1.loggerService.log(METHOD_NAME$R, {
             agentName,
         });
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$Q);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$R);
     return swarm$1.agentMetaService.toUML(agentName, withSubtree);
 });
 
-const METHOD_NAME$P = "cli.dumpSwarm";
+const METHOD_NAME$Q = "cli.dumpSwarm";
 /**
  * Dumps the swarm information into PlantUML format.
  *
@@ -12643,14 +12661,14 @@ const METHOD_NAME$P = "cli.dumpSwarm";
  */
 const dumpSwarm = beginContext((swarmName) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$P, {
+        swarm$1.loggerService.log(METHOD_NAME$Q, {
             swarmName,
         });
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$P);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$Q);
     return swarm$1.swarmMetaService.toUML(swarmName);
 });
 
-const METHOD_NAME$O = "cli.dumpPerfomance";
+const METHOD_NAME$P = "cli.dumpPerfomance";
 const METHOD_NAME_INTERNAL$1 = "cli.dumpPerfomance.internal";
 const METHOD_NAME_INTERVAL = "cli.dumpPerfomance.interval";
 /**
@@ -12669,7 +12687,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$O);
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$P);
     await dumpPerfomanceInternal(dirName);
 };
 /**
@@ -12727,7 +12745,7 @@ const listenExecutionEvent = beginContext((clientId, fn) => {
     return swarm$1.busService.subscribe(clientId, "execution-bus", functoolsKit.queued(async (e) => await fn(e)));
 });
 
-const METHOD_NAME$N = "cli.dumpClientPerformance";
+const METHOD_NAME$O = "cli.dumpClientPerformance";
 const METHOD_NAME_INTERNAL = "cli.dumpClientPerformance.internal";
 const METHOD_NAME_EXECUTE = "cli.dumpClientPerformance.execute";
 /**
@@ -12751,7 +12769,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$N);
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$O);
     await dumpClientPerformanceInternal(clientId, dirName);
 };
 /**
@@ -12771,7 +12789,7 @@ dumpClientPerformance.runAfterExecute = beginContext(async (dirName = "./logs/cl
     });
 });
 
-const METHOD_NAME$M = "function.setup.addAgent";
+const METHOD_NAME$N = "function.setup.addAgent";
 /**
  * Adds a new agent to the agent registry for use within the swarm system.
  *
@@ -12791,7 +12809,7 @@ const METHOD_NAME$M = "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$M, {
+        swarm$1.loggerService.log(METHOD_NAME$N, {
             agentSchema,
         });
     // Register the agent in the validation and schema services
@@ -12801,7 +12819,7 @@ const addAgent = beginContext((agentSchema) => {
     return agentSchema.agentName;
 });
 
-const METHOD_NAME$L = "function.setup.addCompletion";
+const METHOD_NAME$M = "function.setup.addCompletion";
 /**
  * Adds a completion engine to the registry for use by agents in the swarm system.
  *
@@ -12821,7 +12839,7 @@ const METHOD_NAME$L = "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$L, {
+        swarm$1.loggerService.log(METHOD_NAME$M, {
             completionSchema,
         });
     // Register the completion in the validation and schema services
@@ -12831,7 +12849,7 @@ const addCompletion = beginContext((completionSchema) => {
     return completionSchema.completionName;
 });
 
-const METHOD_NAME$K = "function.setup.addSwarm";
+const METHOD_NAME$L = "function.setup.addSwarm";
 /**
  * Adds a new swarm to the system for managing client sessions.
  *
@@ -12851,7 +12869,7 @@ const METHOD_NAME$K = "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$K, {
+        swarm$1.loggerService.log(METHOD_NAME$L, {
             swarmSchema,
         });
     // Register the swarm in the validation and schema services
@@ -12861,7 +12879,7 @@ const addSwarm = beginContext((swarmSchema) => {
     return swarmSchema.swarmName;
 });
 
-const METHOD_NAME$J = "function.setup.addTool";
+const METHOD_NAME$K = "function.setup.addTool";
 /**
  * Adds a new tool to the tool registry for use by agents in the swarm system.
  *
@@ -12883,7 +12901,7 @@ const METHOD_NAME$J = "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$J, {
+        swarm$1.loggerService.log(METHOD_NAME$K, {
             toolSchema,
         });
     // Register the tool in the validation and schema services
@@ -12893,7 +12911,7 @@ const addTool = beginContext((toolSchema) => {
     return toolSchema.toolName;
 });
 
-const METHOD_NAME$I = "function.setup.addState";
+const METHOD_NAME$J = "function.setup.addState";
 /**
  * Adds a new state to the state registry for use within the swarm system.
  *
@@ -12915,7 +12933,7 @@ const METHOD_NAME$I = "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$I, {
+        swarm$1.loggerService.log(METHOD_NAME$J, {
             stateSchema,
         });
     // Register the state in the schema service
@@ -12930,7 +12948,7 @@ const addState = beginContext((stateSchema) => {
     return stateSchema.stateName;
 });
 
-const METHOD_NAME$H = "function.setup.addEmbedding";
+const METHOD_NAME$I = "function.setup.addEmbedding";
 /**
  * Adds a new embedding engine to the embedding registry for use within the swarm system.
  *
@@ -12950,7 +12968,7 @@ const METHOD_NAME$H = "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$H, {
+        swarm$1.loggerService.log(METHOD_NAME$I, {
             embeddingSchema,
         });
     // Register the embedding in the validation and schema services
@@ -12960,7 +12978,7 @@ const addEmbedding = beginContext((embeddingSchema) => {
     return embeddingSchema.embeddingName;
 });
 
-const METHOD_NAME$G = "function.setup.addStorage";
+const METHOD_NAME$H = "function.setup.addStorage";
 /**
  * Adds a new storage engine to the storage registry for use within the swarm system.
  *
@@ -12982,7 +13000,7 @@ const METHOD_NAME$G = "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$G, {
+        swarm$1.loggerService.log(METHOD_NAME$H, {
             storageSchema,
         });
     // Register the storage in the validation and schema services
@@ -12999,7 +13017,7 @@ const addStorage = beginContext((storageSchema) => {
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$F = "function.setup.addPolicy";
+const METHOD_NAME$G = "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.
@@ -13015,7 +13033,7 @@ const METHOD_NAME$F = "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$F, {
+        swarm$1.loggerService.log(METHOD_NAME$G, {
             policySchema,
         });
     // Register the policy with PolicyValidationService for runtime validation
@@ -13026,7 +13044,7 @@ const addPolicy = beginContext((policySchema) => {
     return policySchema.policyName;
 });
 
-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.
  *
@@ -13046,19 +13064,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 &&
@@ -13071,11 +13089,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.
@@ -13094,20 +13112,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', {
@@ -13118,11 +13136,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.
@@ -13139,19 +13157,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', {
@@ -13162,10 +13180,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.
  *
@@ -13184,18 +13202,18 @@ const METHOD_NAME$B = "function.commit.commitSystemMessage";
 const commitUserMessage = 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$B, {
+        swarm$1.loggerService.log(METHOD_NAME$C, {
             content,
             clientId,
             agentName,
         });
     // 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 &&
@@ -13207,10 +13225,10 @@ const commitUserMessage = beginContext(async (content, clientId, agentName) => {
         return;
     }
     // Commit the user message to the agent's history via the session public service
-    await swarm$1.sessionPublicService.commitUserMessage(content, METHOD_NAME$B, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitUserMessage(content, 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.
  *
@@ -13229,21 +13247,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.
@@ -13262,21 +13280,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.
@@ -13294,20 +13312,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.
  *
@@ -13325,20 +13343,20 @@ const METHOD_NAME$x = "function.commit.commitSystemMessage";
 const commitUserMessageForce = 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$x, {
+        swarm$1.loggerService.log(METHOD_NAME$y, {
             content,
             clientId,
         });
     // 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);
     // Commit the user message to the agent's history via the session public service without checking the active agent
-    await swarm$1.sessionPublicService.commitUserMessage(content, METHOD_NAME$x, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitUserMessage(content, 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.
@@ -13356,20 +13374,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', {
@@ -13380,11 +13398,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.
@@ -13403,21 +13421,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.
@@ -13433,19 +13451,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', {
@@ -13456,11 +13474,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.
@@ -13477,20 +13495,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.
@@ -13507,19 +13525,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', {
@@ -13530,11 +13548,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.
@@ -13552,20 +13570,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.
  *
@@ -13584,7 +13602,7 @@ 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,
         });
@@ -13594,14 +13612,14 @@ const emitForce = beginContext(async (content, clientId) => {
         throw new Error(`agent-swarm-kit emitForce session is not makeConnection clientId=${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.
  *
@@ -13622,22 +13640,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;
@@ -13654,7 +13672,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.
  *
@@ -13671,10 +13689,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,
         });
@@ -13741,7 +13759,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}
@@ -13772,7 +13790,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,
         });
@@ -13805,7 +13823,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.
  *
@@ -13827,19 +13845,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', {
@@ -13858,7 +13876,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,
@@ -13878,7 +13896,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.
  *
@@ -13898,7 +13916,7 @@ 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,
@@ -13909,12 +13927,12 @@ const emit = beginContext(async (content, clientId, agentName) => {
         throw new Error(`agent-swarm-kit emit session is not makeConnection clientId=${clientId}`);
     }
     // 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', {
@@ -13925,10 +13943,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.
  *
@@ -13951,19 +13969,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', {
@@ -13982,7 +14000,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,
@@ -14002,7 +14020,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.
  *
@@ -14023,22 +14041,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;
@@ -14055,35 +14073,6 @@ const runStatelessForce = beginContext(async (content, clientId) => {
     });
 });
 
-const METHOD_NAME$i = "function.common.getAgentName";
-/**
- * Retrieves the name of the active agent for a given client session in a swarm.
- *
- * This function fetches the name of the currently active agent associated with the specified client session within a swarm.
- * It validates the client session and swarm, logs the operation if enabled, and delegates the retrieval to the swarm public service.
- * The execution is wrapped in `beginContext` to ensure it runs outside of existing method and execution contexts, providing a clean execution environment.
- *
- * @param {string} clientId - The unique identifier of the client session whose active agent name is being retrieved.
- * @returns {Promise<string>} A promise that resolves to the name of the active agent (`AgentName`) associated with the client session.
- * @throws {Error} If the client session is invalid, the swarm validation fails, or the swarm public service encounters an error during retrieval.
- * @example
- * const agentName = await getAgentName("client-123");
- * console.log(agentName); // Outputs "AgentX"
- */
-const getAgentName = beginContext(async (clientId) => {
-    // Log the operation details if logging is enabled in GLOBAL_CONFIG
-    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$i, {
-            clientId,
-        });
-    // Validate the session and swarm to ensure they exist and are accessible
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$i);
-    const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$i);
-    // Retrieve the active agent name via the swarm public service
-    return await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$i, clientId, swarmName);
-});
-
 /**
  * Delay in milliseconds for scheduled message sending.
  * @constant {number}
@@ -14094,7 +14083,7 @@ const SCHEDULED_DELAY$1 = 1000;
  * @constant {number}
  */
 const RATE_DELAY = 10000;
-const METHOD_NAME$h = "function.target.makeConnection";
+const METHOD_NAME$j = "function.target.makeConnection";
 /**
  * Internal implementation of the connection factory for a client to a swarm.
  *
@@ -14106,28 +14095,28 @@ const METHOD_NAME$h = "function.target.makeConnection";
  * @param {SwarmName} swarmName - The name of the swarm to connect to.
  * @returns {SendMessageFn} A function to send messages to the swarm.
  */
-const makeConnectionInternal = beginContext((connector, clientId, swarmName) => {
+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$h, {
+        swarm$1.loggerService.log(METHOD_NAME$j, {
             clientId,
             swarmName,
         });
     // Validate the swarm and initialize the session
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$h);
+    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$h, 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 beginContext(async (outgoing) => {
-        swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$h);
+    return (async (outgoing) => {
+        swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$j);
         return await send({
             data: outgoing,
-            agentName: await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$h, clientId, swarmName),
+            agentName: await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$j, clientId, swarmName),
             clientId,
         });
     });
-});
+};
 /**
  * A connection factory for establishing a client connection to a swarm, returning a function to send messages.
  *
@@ -14143,7 +14132,20 @@ const makeConnectionInternal = beginContext((connector, clientId, swarmName) =>
  * const sendMessage = makeConnection((msg) => console.log(msg), "client-123", "TaskSwarm");
  * await sendMessage("Hello, swarm!");
  */
-const makeConnection = (connector, clientId, swarmName) => makeConnectionInternal(connector, clientId, swarmName);
+const makeConnection = (connector, clientId, swarmName) => {
+    const send = makeConnectionInternal(connector, clientId, swarmName);
+    return beginContext(async (content, payload = null) => {
+        if (payload) {
+            return await PayloadContextService.runInContext(async () => {
+                return await send(content);
+            }, {
+                clientId,
+                payload,
+            });
+        }
+        return await send(content);
+    });
+};
 /**
  * A scheduled connection factory for a client to a swarm, returning a function to send delayed messages.
  *
@@ -14160,26 +14162,42 @@ const makeConnection = (connector, clientId, swarmName) => makeConnectionInterna
  * const sendScheduled = makeConnection.scheduled((msg) => console.log(msg), "client-123", "TaskSwarm", { delay: 2000 });
  * await sendScheduled("Delayed message"); // Sent after 2 seconds
  */
-makeConnection.scheduled = beginContext((connector, clientId, swarmName, { delay = SCHEDULED_DELAY$1 } = {}) => {
-    const send = makeConnection(connector, clientId, swarmName);
-    const wrappedSend = functoolsKit.schedule(beginContext(async (content) => {
+makeConnection.scheduled = (connector, clientId, swarmName, { delay = SCHEDULED_DELAY$1 } = {}) => {
+    const send = makeConnectionInternal(connector, clientId, swarmName);
+    const wrappedSend = functoolsKit.schedule(beginContext(async (content, payload) => {
         if (!swarm$1.sessionValidationService.hasSession(clientId)) {
             return;
         }
+        if (payload) {
+            return await PayloadContextService.runInContext(async () => {
+                return await send(content);
+            }, {
+                clientId,
+                payload,
+            });
+        }
         return await send(content);
     }), {
-        onSchedule: beginContext(async ([content]) => {
+        onSchedule: beginContext(async ([content, payload]) => {
             if (!swarm$1.sessionValidationService.hasSession(clientId)) {
                 return;
             }
-            await commitUserMessage(content, clientId, await getAgentName(clientId));
+            if (payload) {
+                return await PayloadContextService.runInContext(async () => {
+                    await swarm$1.sessionPublicService.commitUserMessage(content, METHOD_NAME$j, clientId, swarmName);
+                }, {
+                    clientId,
+                    payload,
+                });
+            }
+            await swarm$1.sessionPublicService.commitUserMessage(content, METHOD_NAME$j, clientId, swarmName);
         }),
         delay,
     });
-    return async (content) => {
-        return await wrappedSend(content);
+    return async (content, payload = null) => {
+        return await wrappedSend(content, payload);
     };
-});
+};
 /**
  * A rate-limited connection factory for a client to a swarm, returning a function to send throttled messages.
  *
@@ -14196,21 +14214,29 @@ makeConnection.scheduled = beginContext((connector, clientId, swarmName, { delay
  * const sendRateLimited = makeConnection.rate((msg) => console.log(msg), "client-123", "TaskSwarm", { delay: 5000 });
  * await sendRateLimited("Throttled message"); // Limited to one send every 5 seconds
  */
-makeConnection.rate = beginContext((connector, clientId, swarmName, { delay = RATE_DELAY } = {}) => {
-    const send = makeConnection(connector, clientId, swarmName);
-    const wrappedSend = functoolsKit.rate(beginContext(async (content) => {
+makeConnection.rate = (connector, clientId, swarmName, { delay = RATE_DELAY } = {}) => {
+    const send = makeConnectionInternal(connector, clientId, swarmName);
+    const wrappedSend = functoolsKit.rate(beginContext(async (content, payload) => {
         if (!swarm$1.sessionValidationService.hasSession(clientId)) {
             return;
         }
+        if (payload) {
+            return await PayloadContextService.runInContext(async () => {
+                return await send(content);
+            }, {
+                clientId,
+                payload,
+            });
+        }
         return await send(content);
     }), {
         key: () => clientId,
         rateName: `makeConnection.rate clientId=${clientId}`,
         delay,
     });
-    return async (content) => {
+    return async (content, payload = null) => {
         try {
-            return await wrappedSend(content);
+            return await wrappedSend(content, payload);
         }
         catch (error) {
             if (error?.type === "rate-error") {
@@ -14220,9 +14246,9 @@ makeConnection.rate = beginContext((connector, clientId, swarmName, { delay = RA
             throw error;
         }
     };
-});
+};
 
-const METHOD_NAME$g = "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.
@@ -14284,11 +14310,11 @@ const createGc$3 = functoolsKit.singleshot(async () => {
  * const result = await complete("Calculate 2 + 2", "client-123", "MathSwarm");
  * console.log(result); // Outputs "4"
  */
-const complete = beginContext(async (content, clientId, swarmName) => {
+const complete = beginContext(async (content, clientId, swarmName, payload = null) => {
     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$i, {
             content,
             clientId,
             executionId,
@@ -14298,26 +14324,35 @@ const complete = beginContext(async (content, clientId, swarmName) => {
     const run = await createComplete(clientId, swarmName);
     createGc$3();
     // 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 run(METHOD_NAME$g, content);
-            isFinished = swarm$1.perfService.endExecution(executionId, clientId, result.length);
-            swarm$1.busService.commitExecutionEnd(clientId, { swarmName });
-            return result;
-        }
-        finally {
-            if (!isFinished) {
-                swarm$1.perfService.endExecution(executionId, clientId, 0);
+    const handleRun = async () => {
+        return await ExecutionContextService.runInContext(async () => {
+            let isFinished = false;
+            swarm$1.perfService.startExecution(executionId, clientId, content.length);
+            try {
+                swarm$1.busService.commitExecutionBegin(clientId, { swarmName });
+                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;
             }
-        }
-    }, {
-        clientId,
-        executionId,
-        processId: GLOBAL_CONFIG.CC_PROCESS_UUID,
-    });
+            finally {
+                if (!isFinished) {
+                    swarm$1.perfService.endExecution(executionId, clientId, 0);
+                }
+            }
+        }, {
+            clientId,
+            executionId,
+            processId: GLOBAL_CONFIG.CC_PROCESS_UUID,
+        });
+    };
+    if (payload) {
+        return await PayloadContextService.runInContext(handleRun, {
+            clientId,
+            payload,
+        });
+    }
+    return await handleRun();
 });
 
 /**
@@ -14325,7 +14360,7 @@ const complete = beginContext(async (content, clientId, swarmName) => {
  * @constant {number}
  */
 const SCHEDULED_DELAY = 1000;
-const METHOD_NAME$f = "function.target.session";
+const METHOD_NAME$h = "function.target.session";
 /**
  * Internal implementation of the session factory for a client and swarm.
  *
@@ -14336,26 +14371,26 @@ const METHOD_NAME$f = "function.target.session";
  * @param {SwarmName} swarmName - The name of the swarm to connect to.
  * @returns {Object} An object containing `complete` and `dispose` methods for session management.
  */
-const sessionInternal = beginContext((clientId, swarmName) => {
+const sessionInternal = (clientId, swarmName) => {
     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$f, {
+        swarm$1.loggerService.log(METHOD_NAME$h, {
             clientId,
             swarmName,
             executionId,
         });
     // Validate the swarm and initialize the session
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$f);
+    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$f);
+        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$f, 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;
@@ -14372,12 +14407,12 @@ const sessionInternal = beginContext((clientId, swarmName) => {
         });
     });
     return {
-        complete: beginContext(complete),
-        dispose: beginContext(async () => {
-            return await disposeConnection(clientId, swarmName, METHOD_NAME$f);
+        complete: (async (content) => {
+            return await complete(content);
         }),
+        dispose: async () => await disposeConnection(clientId, swarmName, METHOD_NAME$h),
     };
-});
+};
 /**
  * Creates a session for a client and swarm, providing methods to complete and dispose of it.
  *
@@ -14394,7 +14429,25 @@ const sessionInternal = beginContext((clientId, swarmName) => {
  * console.log(result); // Outputs the swarm's response
  * await dispose();
  */
-const session = (clientId, swarmName) => sessionInternal(clientId, swarmName);
+const session = (clientId, swarmName) => {
+    const { complete, dispose } = sessionInternal(clientId, swarmName);
+    return {
+        complete: beginContext(async (content, payload = null) => {
+            if (payload) {
+                return await PayloadContextService.runInContext(async () => {
+                    return await complete(content);
+                }, {
+                    clientId,
+                    payload,
+                });
+            }
+            return await complete(content);
+        }),
+        dispose: beginContext(async () => {
+            await dispose();
+        }),
+    };
+};
 /**
  * Creates a scheduled session for a client and swarm, delaying content execution.
  *
@@ -14413,30 +14466,46 @@ const session = (clientId, swarmName) => sessionInternal(clientId, swarmName);
  * await dispose();
  */
 session.scheduled = (clientId, swarmName, { delay = SCHEDULED_DELAY } = {}) => {
-    const { complete, dispose } = session(clientId, swarmName);
+    const { complete, dispose } = sessionInternal(clientId, swarmName);
     let isMounted = true;
-    const wrappedComplete = functoolsKit.schedule(beginContext(async (content) => {
+    const wrappedComplete = functoolsKit.schedule(beginContext(async (content, payload) => {
         if (!isMounted) {
             return;
         }
+        if (payload) {
+            return await PayloadContextService.runInContext(async () => {
+                return await complete(content);
+            }, {
+                clientId,
+                payload,
+            });
+        }
         return await complete(content);
     }), {
-        onSchedule: beginContext(async ([content]) => {
+        onSchedule: beginContext(async ([content, payload]) => {
             if (!isMounted) {
                 return;
             }
-            await commitUserMessage(content, clientId, await getAgentName(clientId));
+            if (payload) {
+                return await PayloadContextService.runInContext(async () => {
+                    return await swarm$1.sessionPublicService.commitUserMessage(content, METHOD_NAME$h, clientId, swarmName);
+                }, {
+                    clientId,
+                    payload,
+                });
+            }
+            return await swarm$1.sessionPublicService.commitUserMessage(content, METHOD_NAME$h, clientId, swarmName);
         }),
         delay,
     });
     return {
-        async complete(content) {
-            return await wrappedComplete(content);
+        complete: async (content, payload = null) => {
+            return await wrappedComplete(content, payload);
         },
-        async dispose() {
+        dispose: beginContext(async () => {
             isMounted = false;
             return await dispose();
-        },
+        }),
     };
 };
 /**
@@ -14457,12 +14526,20 @@ session.scheduled = (clientId, swarmName, { delay = SCHEDULED_DELAY } = {}) => {
  * await dispose();
  */
 session.rate = (clientId, swarmName, { delay = SCHEDULED_DELAY } = {}) => {
-    const { complete, dispose } = session(clientId, swarmName);
+    const { complete, dispose } = sessionInternal(clientId, swarmName);
     let isMounted = true;
-    const wrappedComplete = functoolsKit.rate(beginContext(async (content) => {
+    const wrappedComplete = functoolsKit.rate(beginContext(async (content, payload) => {
         if (!isMounted) {
             return;
         }
+        if (payload) {
+            return await PayloadContextService.runInContext(async () => {
+                return await complete(content);
+            }, {
+                clientId,
+                payload,
+            });
+        }
         return await complete(content);
     }), {
         key: () => clientId,
@@ -14470,9 +14547,9 @@ session.rate = (clientId, swarmName, { delay = SCHEDULED_DELAY } = {}) => {
         delay,
     });
     return {
-        async complete(content) {
+        async complete(content, payload = null) {
             try {
-                return await wrappedComplete(content);
+                return await wrappedComplete(content, payload);
             }
             catch (error) {
                 if (error?.type === "rate-error") {
@@ -14482,13 +14559,61 @@ session.rate = (clientId, swarmName, { delay = SCHEDULED_DELAY } = {}) => {
                 throw error;
             }
         },
-        async dispose() {
+        dispose: beginContext(async () => {
             isMounted = false;
             return await dispose();
-        },
+        }),
     };
 };
 
+/** @private Constant defining the method name for logging purposes */
+const METHOD_NAME$g = "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.
+ * @template Payload - The type of the payload object, defaults to a generic object.
+ * @returns A promise resolving to the payload data from the context, or null if no context exists.
+ * @example
+ * const payload = await getPayload<{ id: number }>();
+ * console.log(payload); // { id: number } or {}
+ */
+const getPayload = async () => {
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$g);
+    const result = PayloadContextService.hasContext()
+        ? swarm$1.payloadContextService.context
+        : null;
+    return result;
+};
+
+const METHOD_NAME$f = "function.common.getAgentName";
+/**
+ * Retrieves the name of the active agent for a given client session in a swarm.
+ *
+ * This function fetches the name of the currently active agent associated with the specified client session within a swarm.
+ * It validates the client session and swarm, logs the operation if enabled, and delegates the retrieval to the swarm public service.
+ * The execution is wrapped in `beginContext` to ensure it runs outside of existing method and execution contexts, providing a clean execution environment.
+ *
+ * @param {string} clientId - The unique identifier of the client session whose active agent name is being retrieved.
+ * @returns {Promise<string>} A promise that resolves to the name of the active agent (`AgentName`) associated with the client session.
+ * @throws {Error} If the client session is invalid, the swarm validation fails, or the swarm public service encounters an error during retrieval.
+ * @example
+ * const agentName = await getAgentName("client-123");
+ * console.log(agentName); // Outputs "AgentX"
+ */
+const getAgentName = beginContext(async (clientId) => {
+    // Log the operation details if logging is enabled in GLOBAL_CONFIG
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
+        swarm$1.loggerService.log(METHOD_NAME$f, {
+            clientId,
+        });
+    // Validate the session and swarm to ensure they exist and are accessible
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$f);
+    const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$f);
+    // Retrieve the active agent name via the swarm public service
+    return await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$f, clientId, swarmName);
+});
+
 const METHOD_NAME$e = "function.common.getAgentHistory";
 /**
  * Retrieves the history prepared for a specific agent, incorporating rescue algorithm tweaks.
@@ -16832,6 +16957,7 @@ exports.getAssistantHistory = getAssistantHistory;
 exports.getLastAssistantMessage = getLastAssistantMessage;
 exports.getLastSystemMessage = getLastSystemMessage;
 exports.getLastUserMessage = getLastUserMessage;
+exports.getPayload = getPayload;
 exports.getRawHistory = getRawHistory;
 exports.getSessionContext = getSessionContext;
 exports.getSessionMode = getSessionMode;