agent-swarm-kit 1.1.26 → 1.1.28

package/build/index.cjs

@@ -429,7 +429,7 @@ async function writeFileAtomic(file, data, options = {}) {
     }
 }
 
-var _a$4, _b$3, _c$1, _d$1, _e;
+var _a$4, _b$2, _c$1, _d$1, _e;
 /** @private Symbol for memoizing the wait-for-initialization operation in PersistBase */
 const BASE_WAIT_FOR_INIT_SYMBOL = Symbol("wait-for-init");
 /** @private Symbol for creating a new key in a persistent list */
@@ -990,7 +990,7 @@ const PersistList = functoolsKit.makeExtendable((_e = class extends PersistBase
              * @returns {Promise<string>} A promise resolving to the new key as a string (e.g., "1", "2").
              * @throws {Error} If key generation fails due to underlying storage issues.
              */
-            this[_b$3] = functoolsKit.queued(async () => await LIST_CREATE_KEY_FN(this));
+            this[_b$2] = functoolsKit.queued(async () => await LIST_CREATE_KEY_FN(this));
             /**
              * Retrieves the key of the last item in the list.
              * Scans all keys to find the highest numeric value, used for pop operations (e.g., dequeuing from a `SwarmName` log).
@@ -1044,7 +1044,7 @@ const PersistList = functoolsKit.makeExtendable((_e = class extends PersistBase
             return await this[LIST_POP_SYMBOL]();
         }
     },
-    _b$3 = LIST_CREATE_KEY_SYMBOL,
+    _b$2 = LIST_CREATE_KEY_SYMBOL,
     _c$1 = LIST_GET_LAST_KEY_SYMBOL,
     _d$1 = LIST_POP_SYMBOL,
     _e));
@@ -1747,7 +1747,7 @@ const PersistEmbeddingAdapter = new PersistEmbeddingUtils();
  */
 const PersistEmbedding = PersistEmbeddingAdapter;
 
-var _a$3, _b$2, _c, _d;
+var _a$3, _b$1, _c, _d;
 /** @private Symbol for memoizing the waitForInit method in HistoryMemoryInstance */
 const HISTORY_MEMORY_INSTANCE_WAIT_FOR_INIT = Symbol("wait-for-init");
 /** @private Symbol for memoizing the waitForInit method in HistoryPersistInstance */
@@ -1831,7 +1831,7 @@ const HISTORY_PERSIST_INSTANCE_WAIT_FOR_INIT_FN = async (agentName, self) => {
  * Manages a persistent history of messages, storing them in memory and on disk.
  * @implements {IHistoryInstance}
  */
-const HistoryPersistInstance = functoolsKit.makeExtendable((_b$2 = class {
+const HistoryPersistInstance = functoolsKit.makeExtendable((_b$1 = class {
         /**
          * Initializes the history for an agent, loading data from persistent storage if needed.
          * @param agentName - The name of the agent.
@@ -2022,7 +2022,7 @@ const HistoryPersistInstance = functoolsKit.makeExtendable((_b$2 = class {
         }
     },
     _a$3 = HISTORY_PERSIST_INSTANCE_WAIT_FOR_INIT,
-    _b$2));
+    _b$1));
 /**
  * Manages an in-memory history of messages without persistence.
  * @implements {IHistoryInstance}
@@ -2451,7 +2451,7 @@ const beginContext = (run) => (...args) => {
     return run(...args);
 };
 
-var _a$2, _b$1;
+var _a$2, _b;
 /** @private Symbol for memoizing the waitForInit method in LoggerInstance */
 const LOGGER_INSTANCE_WAIT_FOR_INIT = Symbol("wait-for-init");
 /**
@@ -2472,7 +2472,7 @@ const LOGGER_INSTANCE_WAIT_FOR_FN = async (self) => {
  * Integrates with GLOBAL_CONFIG for console logging control and callbacks for custom behavior.
  * @implements {ILoggerInstance}
  */
-const LoggerInstance = functoolsKit.makeExtendable((_b$1 = class {
+const LoggerInstance = functoolsKit.makeExtendable((_b = class {
         /**
          * Creates a new logger instance for a specific client.
          * @param clientId - The client ID associated with this logger instance, used in log prefixes.
@@ -2549,7 +2549,7 @@ const LoggerInstance = functoolsKit.makeExtendable((_b$1 = class {
         }
     },
     _a$2 = LOGGER_INSTANCE_WAIT_FOR_INIT,
-    _b$1));
+    _b));
 /**
  * Provides utilities for managing logger instances and common logging operations.
  * Implements ILoggerAdapter for client-specific logging and ILoggerControl for configuration.
@@ -4912,6 +4912,50 @@ const getAgentName = beginContext(async (clientId) => {
     return await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1c, clientId, swarmName);
 });
 
+/** @private Constant defining the method name for logging and validation context */
+const METHOD_NAME$1b = "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.
+ * Runs within a beginContext wrapper for execution context management, logging operations via LoggerService.
+ * Integrates with AgentValidationService (agent validation), SessionValidationService (session and swarm retrieval),
+ * SwarmValidationService (swarm validation), SwarmPublicService (agent retrieval), SessionPublicService (tool execution stop),
+ * ToolValidationService (tool context), and LoggerService (logging). Complements functions like commitFlush by controlling tool flow rather than clearing history.
+ *
+ * @param {string} clientId - The ID of the client associated with the session, validated against active sessions.
+ * @param {string} agentName - The name of the agent whose next tool execution is to be stopped, validated against registered agents.
+ * @returns {Promise<void>} A promise that resolves when the tool stop is committed or skipped (e.g., agent mismatch).
+ * @throws {Error} If agent, session, or swarm validation fails, propagated from respective validation services.
+ */
+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$1b, {
+            clientId,
+            agentName,
+        });
+    // Validate the agent exists
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1b);
+    // Validate the session exists and retrieve the associated swarm
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1b);
+    const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
+    // Validate the swarm configuration
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1b);
+    // Check if the current agent matches the provided agent
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1b, clientId, swarmName);
+    if (currentAgentName !== agentName) {
+        GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
+            swarm$1.loggerService.log('function "commitStopTools" skipped due to the agent change', {
+                currentAgentName,
+                agentName,
+                clientId,
+            });
+        return;
+    }
+    // Commit the stop of the next tool execution via SessionPublicService
+    await swarm$1.sessionPublicService.commitStopTools(METHOD_NAME$1b, clientId, swarmName);
+});
+
 const METHOD_NAME_UPDATE$2 = "McpUtils.update";
 /**
  * A no-operation implementation of the IMCP interface.
@@ -5089,6 +5133,7 @@ class MergeMCP {
                 }
                 catch (error) {
                     console.error(`agent-swarm MCP tool error toolName=${toolName} agentName=${agentName} error=${functoolsKit.getErrorMessage(error)}`);
+                    await commitStopTools(dto.clientId, agentName);
                     await commitFlush(dto.clientId, agentName);
                     await emit(createPlaceholder(), dto.clientId, agentName);
                 }
@@ -5421,7 +5466,7 @@ class AgentConnectionService {
 }
 
 /** @private Constant defining the method name for logging purposes */
-const METHOD_NAME$1b = "function.common.getPayload";
+const METHOD_NAME$1a = "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.
@@ -5432,7 +5477,7 @@ const METHOD_NAME$1b = "function.common.getPayload";
  * console.log(payload); // { id: number } or null
  */
 const getPayload = () => {
-    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$1b);
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$1a);
     if (PayloadContextService.hasContext()) {
         const { payload } = swarm$1.payloadContextService.context;
         return payload;
@@ -15820,6 +15865,9 @@ class ComputeSchemaService {
             if (typeof computeSchema.computeName !== "string") {
                 throw new Error(`agent-swarm compute schema validation failed: missing computeName`);
             }
+            if (computeSchema.ttl && typeof computeSchema.ttl !== "number") {
+                throw new Error(`agent-swarm compute schema validation failed: invalid ttl`);
+            }
             if (typeof computeSchema.getComputeData !== "function") {
                 throw new Error(`agent-swarm compute schema validation failed: missing getComputeData for computeName=${computeSchema.computeName}`);
             }
@@ -16033,7 +16081,7 @@ class StateValidationService {
  * @module ClientCompute
  * @description Provides a class for managing client-side computations with event handling and state management.
  */
-var _a$1, _b;
+var _a$1;
 /**
  * @constant {symbol} DISPOSE_SLOT_FN_SYMBOL
  * @description Symbol for the dispose function slot.
@@ -16094,18 +16142,15 @@ class ClientCompute {
          * @private
          */
         this[_a$1] = () => { };
-        /**
-         * @property {Function} GET_COMPUTE_DATA_FN_SYMBOL
-         * @description Memoized function for retrieving compute data.
-         * @private
-         */
-        this[_b] = functoolsKit.singleshot(async () => {
-            return await GET_COMPUTE_DATA_FN(this);
-        });
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
             this.params.logger.debug(`ClientCompute computeName=${this.params.computeName} clientId=${this.params.clientId} shared=${this.params.shared} CTOR`, {
                 params,
             });
+        this[GET_COMPUTE_DATA_FN_SYMBOL] = functoolsKit.ttl(async () => {
+            return await GET_COMPUTE_DATA_FN(this);
+        }, {
+            timeout: params.ttl,
+        });
         this.params.binding.forEach(({ stateChanged }) => (this[DISPOSE_SLOT_FN_SYMBOL] = functoolsKit.compose(this[DISPOSE_SLOT_FN_SYMBOL], stateChanged.subscribe((stateName) => this.calculate(stateName)))));
         if (this.params.callbacks?.onInit) {
             this.params.callbacks.onInit(this.params.clientId, this.params.computeName);
@@ -16162,12 +16207,17 @@ class ClientCompute {
         }
     }
 }
-_a$1 = DISPOSE_SLOT_FN_SYMBOL, _b = GET_COMPUTE_DATA_FN_SYMBOL;
+_a$1 = DISPOSE_SLOT_FN_SYMBOL;
 
 /**
  * @module ComputeConnectionService
  * @description Manages compute instances and their lifecycle, integrating with dependency injection and state management.
  */
+/**
+ * @constant {number} DEFAULT_COMPUTE_TTL
+ * @description Default time-to-live (TTL) for compute instances, set to 24 hours.
+ */
+const DEFAULT_COMPUTE_TTL = 24 * 60 * 60 * 1000;
 /**
  * @class ComputeConnectionService
  * @template T - Type extending IComputeData.
@@ -16233,7 +16283,7 @@ class ComputeConnectionService {
          */
         this.getComputeRef = functoolsKit.memoize(([clientId, computeName]) => `${clientId}-${computeName}`, (clientId, computeName) => {
             this.sessionValidationService.addComputeUsage(clientId, computeName);
-            const { getComputeData, dependsOn = [], middlewares = [], callbacks, shared = false, } = this.computeSchemaService.get(computeName);
+            const { getComputeData, dependsOn = [], middlewares = [], callbacks, ttl = DEFAULT_COMPUTE_TTL, shared = false, } = this.computeSchemaService.get(computeName);
             if (shared) {
                 this._sharedComputeSet.add(computeName);
                 return this.sharedComputeConnectionService.getComputeRef(computeName);
@@ -16245,6 +16295,7 @@ class ComputeConnectionService {
                 bus: this.busService,
                 getComputeData,
                 binding: dependsOn.map((stateName) => this.stateConnectionService.getStateRef(clientId, stateName)),
+                ttl,
                 dependsOn,
                 middlewares,
                 callbacks,
@@ -16836,7 +16887,7 @@ const swarm = {
 init();
 var swarm$1 = swarm;
 
-const METHOD_NAME$1a = "cli.dumpDocs";
+const METHOD_NAME$19 = "cli.dumpDocs";
 /**
  * Dumps the documentation for the agents and swarms.
  *
@@ -16846,7 +16897,7 @@ const METHOD_NAME$1a = "cli.dumpDocs";
  */
 const dumpDocs = beginContext((prefix = "swarm", dirName = "./docs/chat", PlantUML) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$1a, {
+        swarm$1.loggerService.log(METHOD_NAME$19, {
             dirName,
         });
     if (PlantUML) {
@@ -16856,10 +16907,10 @@ const dumpDocs = beginContext((prefix = "swarm", dirName = "./docs/chat", PlantU
     }
     swarm$1.agentValidationService
         .getAgentList()
-        .forEach((agentName) => swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1a));
+        .forEach((agentName) => swarm$1.agentValidationService.validate(agentName, METHOD_NAME$19));
     swarm$1.swarmValidationService
         .getSwarmList()
-        .forEach((swarmName) => swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1a));
+        .forEach((swarmName) => swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$19));
     swarm$1.agentValidationService.getAgentList().forEach((agentName) => {
         const { dependsOn } = swarm$1.agentSchemaService.get(agentName);
         if (!dependsOn) {
@@ -16869,7 +16920,7 @@ const dumpDocs = beginContext((prefix = "swarm", dirName = "./docs/chat", PlantU
     return swarm$1.docService.dumpDocs(prefix, dirName);
 });
 
-const METHOD_NAME$19 = "cli.dumpAgent";
+const METHOD_NAME$18 = "cli.dumpAgent";
 /**
  * Dumps the agent information into PlantUML format.
  *
@@ -16878,14 +16929,14 @@ const METHOD_NAME$19 = "cli.dumpAgent";
  */
 const dumpAgent = beginContext((agentName, { withSubtree = false } = {}) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$19, {
+        swarm$1.loggerService.log(METHOD_NAME$18, {
             agentName,
         });
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$19);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$18);
     return swarm$1.agentMetaService.toUML(agentName, withSubtree);
 });
 
-const METHOD_NAME$18 = "cli.dumpSwarm";
+const METHOD_NAME$17 = "cli.dumpSwarm";
 /**
  * Dumps the swarm information into PlantUML format.
  *
@@ -16894,14 +16945,14 @@ const METHOD_NAME$18 = "cli.dumpSwarm";
  */
 const dumpSwarm = beginContext((swarmName) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$18, {
+        swarm$1.loggerService.log(METHOD_NAME$17, {
             swarmName,
         });
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$18);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$17);
     return swarm$1.swarmMetaService.toUML(swarmName);
 });
 
-const METHOD_NAME$17 = "cli.dumpPerfomance";
+const METHOD_NAME$16 = "cli.dumpPerfomance";
 const METHOD_NAME_INTERNAL$1 = "cli.dumpPerfomance.internal";
 const METHOD_NAME_INTERVAL = "cli.dumpPerfomance.interval";
 /**
@@ -16920,7 +16971,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$17);
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$16);
     await dumpPerfomanceInternal(dirName);
 };
 /**
@@ -16978,7 +17029,7 @@ const listenExecutionEvent = beginContext((clientId, fn) => {
     return swarm$1.busService.subscribe(clientId, "execution-bus", functoolsKit.queued(async (e) => await fn(e)));
 });
 
-const METHOD_NAME$16 = "cli.dumpClientPerformance";
+const METHOD_NAME$15 = "cli.dumpClientPerformance";
 const METHOD_NAME_INTERNAL = "cli.dumpClientPerformance.internal";
 const METHOD_NAME_EXECUTE = "cli.dumpClientPerformance.execute";
 /**
@@ -17002,7 +17053,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$16);
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$15);
     await dumpClientPerformanceInternal(clientId, dirName);
 };
 /**
@@ -17023,7 +17074,7 @@ dumpClientPerformance.runAfterExecute = beginContext(async (dirName = "./logs/cl
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$15 = "function.commit.commitFlushForce";
+const METHOD_NAME$14 = "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.
@@ -17041,20 +17092,20 @@ const METHOD_NAME$15 = "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$15, {
+        swarm$1.loggerService.log(METHOD_NAME$14, {
             clientId,
-            METHOD_NAME: METHOD_NAME$15,
+            METHOD_NAME: METHOD_NAME$14,
         });
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$15);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$14);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$15);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$14);
     // Commit the flush of agent history via SessionPublicService without agent checks
-    await swarm$1.sessionPublicService.commitFlush(METHOD_NAME$15, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitFlush(METHOD_NAME$14, clientId, swarmName);
 });
 
-const METHOD_NAME$14 = "function.commit.commitToolOutputForce";
+const METHOD_NAME$13 = "function.commit.commitToolOutputForce";
 /**
  * Commits the output of a tool execution to the active agent in a swarm session without checking the active agent.
  *
@@ -17073,24 +17124,24 @@ const METHOD_NAME$14 = "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$14, {
+        swarm$1.loggerService.log(METHOD_NAME$13, {
             toolId,
             content,
             clientId,
         });
     // Validate the session and swarm to ensure they exist and are accessible
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$14);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$13);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$14);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$13);
     // 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$14, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitToolOutput(toolId, content, METHOD_NAME$13, clientId, swarmName);
 });
 
 /**
  * @private Constant defining the method name for logging and validation purposes.
  * Used as an identifier in log messages and validation checks to track calls to `hasNavigation`.
  */
-const METHOD_NAME$13 = "function.common.hasNavigation";
+const METHOD_NAME$12 = "function.common.hasNavigation";
 /**
  * Checks if a specific agent is part of the navigation route for a given client.
  * Validates the agent and client session, retrieves the associated swarm, and queries the navigation route.
@@ -17101,16 +17152,16 @@ const METHOD_NAME$13 = "function.common.hasNavigation";
  */
 const hasNavigation = async (clientId, agentName) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$13, { clientId });
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$13);
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$13);
+        swarm$1.loggerService.log(METHOD_NAME$12, { clientId });
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$12);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$12);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     return swarm$1.navigationValidationService
         .getNavigationRoute(clientId, swarmName)
         .has(agentName);
 };
 
-const METHOD_NAME$12 = "function.history.getRawHistory";
+const METHOD_NAME$11 = "function.history.getRawHistory";
 /**
  * Retrieves the raw, unmodified history for a given client session.
  *
@@ -17127,10 +17178,10 @@ const METHOD_NAME$12 = "function.history.getRawHistory";
  * const rawHistory = await getRawHistory("client-123");
  * console.log(rawHistory); // Outputs the full raw history array
  */
-const getRawHistory = beginContext(async (clientId, methodName = METHOD_NAME$12) => {
+const getRawHistory = beginContext(async (clientId, methodName = METHOD_NAME$11) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$12, {
+        swarm$1.loggerService.log(METHOD_NAME$11, {
             clientId,
         });
     // Validate the session and swarm
@@ -17143,7 +17194,7 @@ const getRawHistory = beginContext(async (clientId, methodName = METHOD_NAME$12)
     return [...history];
 });
 
-const METHOD_NAME$11 = "function.history.getLastUserMessage";
+const METHOD_NAME$10 = "function.history.getLastUserMessage";
 /**
  * Retrieves the content of the most recent user message from a client's session history.
  *
@@ -17161,16 +17212,16 @@ const METHOD_NAME$11 = "function.history.getLastUserMessage";
 const getLastUserMessage = 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$11, {
+        swarm$1.loggerService.log(METHOD_NAME$10, {
             clientId,
         });
     // Fetch raw history and find the last user message
-    const history = await getRawHistory(clientId, METHOD_NAME$11);
+    const history = await getRawHistory(clientId, METHOD_NAME$10);
     const last = history.findLast(({ role, mode }) => role === "user" && mode === "user");
     return last?.content ? last.content : null;
 });
 
-const METHOD_NAME$10 = "function.navigate.changeToDefaultAgent";
+const METHOD_NAME$$ = "function.navigate.changeToDefaultAgent";
 /**
  * Time-to-live for the change agent function in milliseconds.
  * Defines how long the cached change agent function remains valid before expiring.
@@ -17205,7 +17256,7 @@ const createChangeToDefaultAgent = functoolsKit.ttl((clientId) => functoolsKit.q
     }));
     {
         // Dispose of the current agent's resources and set up the new default agent
-        const agentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$10, clientId, swarmName);
+        const agentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$$, clientId, swarmName);
         await swarm$1.agentPublicService.dispose(methodName, clientId, agentName);
         await swarm$1.historyPublicService.dispose(methodName, clientId, agentName);
         await swarm$1.swarmPublicService.setAgentRef(methodName, clientId, swarmName, agentName, await swarm$1.agentPublicService.createAgentRef(methodName, clientId, agentName));
@@ -17244,23 +17295,23 @@ const createGc$3 = functoolsKit.singleshot(async () => {
 const changeToDefaultAgent = 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$10, {
+        swarm$1.loggerService.log(METHOD_NAME$$, {
             clientId,
         });
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     const { defaultAgent: agentName } = swarm$1.swarmSchemaService.get(swarmName);
     {
         // Validate session and default agent
-        swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$10);
-        swarm$1.agentValidationService.validate(agentName, METHOD_NAME$10);
+        swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$$);
+        swarm$1.agentValidationService.validate(agentName, METHOD_NAME$$);
     }
     // Execute the agent change with TTL and queuing
     const run = await createChangeToDefaultAgent(clientId);
     createGc$3();
-    return await run(METHOD_NAME$10, agentName, swarmName);
+    return await run(METHOD_NAME$$, agentName, swarmName);
 });
 
-const METHOD_NAME$$ = "function.target.emitForce";
+const METHOD_NAME$_ = "function.target.emitForce";
 /**
  * Emits a string as model output without executing an incoming message or checking the active agent.
  *
@@ -17279,19 +17330,19 @@ const METHOD_NAME$$ = "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$$, {
+        swarm$1.loggerService.log(METHOD_NAME$_, {
             content,
             clientId,
         });
     // Validate the session and swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$$);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$_);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$$);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$_);
     // Emit the content directly via the session public service
-    return await swarm$1.sessionPublicService.emit(content, METHOD_NAME$$, clientId, swarmName);
+    return await swarm$1.sessionPublicService.emit(content, METHOD_NAME$_, clientId, swarmName);
 });
 
-const METHOD_NAME$_ = "function.target.executeForce";
+const METHOD_NAME$Z = "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.
  *
@@ -17312,22 +17363,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$_, {
+        swarm$1.loggerService.log(METHOD_NAME$Z, {
             content,
             clientId,
             executionId,
         });
     // Validate the session and swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$_);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$Z);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$_);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$Z);
     // 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$_, clientId, swarmName);
+            const result = await swarm$1.sessionPublicService.execute(content, "tool", METHOD_NAME$Z, clientId, swarmName);
             isFinished = swarm$1.perfService.endExecution(executionId, clientId, result.length);
             swarm$1.busService.commitExecutionEnd(clientId, { swarmName });
             return result;
@@ -17344,7 +17395,7 @@ const executeForce = beginContext(async (content, clientId) => {
     });
 });
 
-const METHOD_NAME$Z = "function.template.navigateToTriageAgent";
+const METHOD_NAME$Y = "function.template.navigateToTriageAgent";
 /**
  * Will send tool output directly to the model without any additions
  */
@@ -17395,7 +17446,7 @@ const createNavigateToTriageAgent = ({ flushMessage, lastMessage: lastMessageFn
      */
     return beginContext(async (toolId, clientId) => {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-            swarm$1.loggerService.log(METHOD_NAME$Z, {
+            swarm$1.loggerService.log(METHOD_NAME$Y, {
                 clientId,
                 toolId,
             });
@@ -17427,7 +17478,7 @@ const createNavigateToTriageAgent = ({ flushMessage, lastMessage: lastMessageFn
     });
 };
 
-const METHOD_NAME$Y = "function.navigate.changeToAgent";
+const METHOD_NAME$X = "function.navigate.changeToAgent";
 /**
  * Time-to-live for the change agent function in milliseconds.
  * Defines how long the cached change agent function remains valid before expiring.
@@ -17463,7 +17514,7 @@ const createChangeToAgent = functoolsKit.ttl((clientId) => functoolsKit.queued(a
     }));
     {
         // Dispose of the current agent's resources and set up the new agent
-        const agentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$Y, clientId, swarmName);
+        const agentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$X, clientId, swarmName);
         await swarm$1.agentPublicService.dispose(methodName, clientId, agentName);
         await swarm$1.historyPublicService.dispose(methodName, clientId, agentName);
         await swarm$1.swarmPublicService.setAgentRef(methodName, clientId, swarmName, agentName, await swarm$1.agentPublicService.createAgentRef(methodName, clientId, agentName));
@@ -17503,16 +17554,16 @@ const createGc$2 = functoolsKit.singleshot(async () => {
 const changeToAgent = beginContext(async (agentName, clientId) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$Y, {
+        swarm$1.loggerService.log(METHOD_NAME$X, {
             agentName,
             clientId,
         });
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     {
         // Validate session, agent, and dependencies
-        swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$Y);
-        swarm$1.agentValidationService.validate(agentName, METHOD_NAME$Y);
-        const activeAgent = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$Y, clientId, swarmName);
+        swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$X);
+        swarm$1.agentValidationService.validate(agentName, METHOD_NAME$X);
+        const activeAgent = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$X, clientId, swarmName);
         if (!swarm$1.agentValidationService.hasDependency(activeAgent, agentName)) {
             console.error(`agent-swarm missing dependency detected for activeAgent=${activeAgent} dependencyAgent=${agentName}`);
         }
@@ -17530,10 +17581,10 @@ const changeToAgent = beginContext(async (agentName, clientId) => {
     // Execute the agent change with TTL and queuing
     const run = await createChangeToAgent(clientId);
     createGc$2();
-    return await run(METHOD_NAME$Y, agentName, swarmName);
+    return await run(METHOD_NAME$X, agentName, swarmName);
 });
 
-const METHOD_NAME$X = "function.template.navigateToAgent";
+const METHOD_NAME$W = "function.template.navigateToAgent";
 /**
  * Will send tool output directly to the model without any additions
  */
@@ -17599,7 +17650,7 @@ const createNavigateToAgent = ({ executeMessage = DEFAULT_EXECUTE_MESSAGE, emitM
      */
     return beginContext(async (toolId, clientId, agentName) => {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-            swarm$1.loggerService.log(METHOD_NAME$X, {
+            swarm$1.loggerService.log(METHOD_NAME$W, {
                 clientId,
                 toolId,
             });
@@ -17632,7 +17683,7 @@ const createNavigateToAgent = ({ executeMessage = DEFAULT_EXECUTE_MESSAGE, emitM
     });
 };
 
-const METHOD_NAME$W = "function.setup.addTool";
+const METHOD_NAME$V = "function.setup.addTool";
 /**
  * Adds a new tool to the tool registry for use by agents in the swarm system.
  *
@@ -17654,7 +17705,7 @@ const METHOD_NAME$W = "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$W, {
+        swarm$1.loggerService.log(METHOD_NAME$V, {
             toolSchema,
         });
     // Register the tool in the validation and schema services
@@ -17668,7 +17719,7 @@ const addTool = beginContext((toolSchema) => {
  * Adds navigation functionality to an agent by creating a tool that allows navigation to a specified agent.
  * @module addAgentNavigation
  */
-const METHOD_NAME$V = "function.alias.addAgentNavigation";
+const METHOD_NAME$U = "function.alias.addAgentNavigation";
 const DEFAULT_SKIP_PLACEHOLDER$1 = "Navigation canceled";
 /**
  * Creates and registers a navigation tool for an agent to navigate to another specified agent.
@@ -17682,7 +17733,7 @@ const DEFAULT_SKIP_PLACEHOLDER$1 = "Navigation canceled";
  * @returns {ReturnType<typeof addTool>} The result of adding the navigation tool.
  */
 const addAgentNavigation = beginContext(({ toolName, docNote, description, navigateTo, skipPlaceholder = DEFAULT_SKIP_PLACEHOLDER$1, ...navigateProps }) => {
-    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$V);
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$U);
     const navigate = createNavigateToAgent(navigateProps);
     return addTool({
         toolName,
@@ -17711,7 +17762,7 @@ const addAgentNavigation = beginContext(({ toolName, docNote, description, navig
  * Adds triage navigation functionality to an agent by creating a tool that facilitates navigation to a triage agent.
  * @module addTriageNavigation
  */
-const METHOD_NAME$U = "function.alias.addTriageNavigation";
+const METHOD_NAME$T = "function.alias.addTriageNavigation";
 const DEFAULT_SKIP_PLACEHOLDER = "Navigation canceled";
 /**
  * Creates and registers a triage navigation tool for an agent to navigate to a triage agent.
@@ -17724,7 +17775,7 @@ const DEFAULT_SKIP_PLACEHOLDER = "Navigation canceled";
  * @returns {ReturnType<typeof addTool>} The result of adding the triage navigation tool.
  */
 const addTriageNavigation = beginContext(({ toolName, docNote, description, skipPlaceholder = DEFAULT_SKIP_PLACEHOLDER, ...navigateProps }) => {
-    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$T);
     const navigate = createNavigateToTriageAgent(navigateProps);
     return addTool({
         toolName,
@@ -17750,7 +17801,7 @@ const addTriageNavigation = beginContext(({ toolName, docNote, description, skip
 });
 
 /** @constant {string} METHOD_NAME - The name of the method used for logging */
-const METHOD_NAME$T = "function.setup.addWiki";
+const METHOD_NAME$S = "function.setup.addWiki";
 /**
  * Adds a wiki schema to the system
  * @function addWiki
@@ -17759,7 +17810,7 @@ const METHOD_NAME$T = "function.setup.addWiki";
  */
 const addWiki = beginContext((wikiSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$T, {
+        swarm$1.loggerService.log(METHOD_NAME$S, {
             wikiSchema,
         });
     swarm$1.wikiValidationService.addWiki(wikiSchema.wikiName, wikiSchema);
@@ -17767,7 +17818,7 @@ const addWiki = beginContext((wikiSchema) => {
     return wikiSchema.wikiName;
 });
 
-const METHOD_NAME$S = "function.setup.addAgent";
+const METHOD_NAME$R = "function.setup.addAgent";
 /**
  * Adds a new agent to the agent registry for use within the swarm system.
  *
@@ -17787,7 +17838,7 @@ const METHOD_NAME$S = "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$S, {
+        swarm$1.loggerService.log(METHOD_NAME$R, {
             agentSchema,
         });
     // Register the agent in the validation and schema services
@@ -17797,7 +17848,7 @@ const addAgent = beginContext((agentSchema) => {
     return agentSchema.agentName;
 });
 
-const METHOD_NAME$R = "function.setup.addCompletion";
+const METHOD_NAME$Q = "function.setup.addCompletion";
 /**
  * Adds a completion engine to the registry for use by agents in the swarm system.
  *
@@ -17817,7 +17868,7 @@ const METHOD_NAME$R = "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$R, {
+        swarm$1.loggerService.log(METHOD_NAME$Q, {
             completionSchema,
         });
     // Register the completion in the validation and schema services
@@ -17827,7 +17878,7 @@ const addCompletion = beginContext((completionSchema) => {
     return completionSchema.completionName;
 });
 
-const METHOD_NAME$Q = "function.setup.addSwarm";
+const METHOD_NAME$P = "function.setup.addSwarm";
 /**
  * Adds a new swarm to the system for managing client sessions.
  *
@@ -17847,7 +17898,7 @@ const METHOD_NAME$Q = "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$Q, {
+        swarm$1.loggerService.log(METHOD_NAME$P, {
             swarmSchema,
         });
     // Register the swarm in the validation and schema services
@@ -17857,7 +17908,7 @@ const addSwarm = beginContext((swarmSchema) => {
     return swarmSchema.swarmName;
 });
 
-const METHOD_NAME$P = "function.setup.addMCP";
+const METHOD_NAME$O = "function.setup.addMCP";
 /**
  * Registers a new MCP (Model Context Protocol) schema in the system.
  * @param mcpSchema - The MCP schema to register.
@@ -17865,7 +17916,7 @@ const METHOD_NAME$P = "function.setup.addMCP";
  */
 const addMCP = beginContext((mcpSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$P, {
+        swarm$1.loggerService.log(METHOD_NAME$O, {
             mcpSchema,
         });
     swarm$1.mcpValidationService.addMCP(mcpSchema.mcpName, mcpSchema);
@@ -17873,7 +17924,7 @@ const addMCP = beginContext((mcpSchema) => {
     return mcpSchema.mcpName;
 });
 
-const METHOD_NAME$O = "function.setup.addState";
+const METHOD_NAME$N = "function.setup.addState";
 /**
  * Adds a new state to the state registry for use within the swarm system.
  *
@@ -17895,7 +17946,7 @@ const METHOD_NAME$O = "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$O, {
+        swarm$1.loggerService.log(METHOD_NAME$N, {
             stateSchema,
         });
     // Register the policy with StateValidationService for runtime validation
@@ -17912,7 +17963,7 @@ const addState = beginContext((stateSchema) => {
     return stateSchema.stateName;
 });
 
-const METHOD_NAME$N = "function.setup.addEmbedding";
+const METHOD_NAME$M = "function.setup.addEmbedding";
 /**
  * Adds a new embedding engine to the embedding registry for use within the swarm system.
  *
@@ -17932,7 +17983,7 @@ const METHOD_NAME$N = "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$N, {
+        swarm$1.loggerService.log(METHOD_NAME$M, {
             embeddingSchema,
         });
     // Register the embedding in the validation and schema services
@@ -17942,7 +17993,7 @@ const addEmbedding = beginContext((embeddingSchema) => {
     return embeddingSchema.embeddingName;
 });
 
-const METHOD_NAME$M = "function.setup.addStorage";
+const METHOD_NAME$L = "function.setup.addStorage";
 /**
  * Adds a new storage engine to the storage registry for use within the swarm system.
  *
@@ -17964,7 +18015,7 @@ const METHOD_NAME$M = "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$M, {
+        swarm$1.loggerService.log(METHOD_NAME$L, {
             storageSchema,
         });
     // Register the storage in the validation and schema services
@@ -17981,7 +18032,7 @@ const addStorage = beginContext((storageSchema) => {
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$L = "function.setup.addPolicy";
+const METHOD_NAME$K = "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.
@@ -17997,7 +18048,7 @@ const METHOD_NAME$L = "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$L, {
+        swarm$1.loggerService.log(METHOD_NAME$K, {
             policySchema,
         });
     // Register the policy with PolicyValidationService for runtime validation
@@ -18029,7 +18080,7 @@ const addCompute = beginContext((computeSchema) => {
     return computeSchema.computeName;
 });
 
-const METHOD_NAME$K = "function.test.overrideAgent";
+const METHOD_NAME$J = "function.test.overrideAgent";
 /**
  * Overrides an existing agent schema in the swarm system with a new or partial schema.
  * This function updates the configuration of an agent identified by its `agentName`, applying the provided schema properties.
@@ -18053,13 +18104,13 @@ const METHOD_NAME$K = "function.test.overrideAgent";
  */
 const overrideAgent = beginContext((agentSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$K, {
+        swarm$1.loggerService.log(METHOD_NAME$J, {
             agentSchema,
         });
     return swarm$1.agentSchemaService.override(agentSchema.agentName, agentSchema);
 });
 
-const METHOD_NAME$J = "function.test.overrideCompletion";
+const METHOD_NAME$I = "function.test.overrideCompletion";
 /**
  * Overrides an existing completion schema in the swarm system with a new or partial schema.
  * This function updates the configuration of a completion mechanism identified by its `completionName`, applying the provided schema properties.
@@ -18083,13 +18134,13 @@ const METHOD_NAME$J = "function.test.overrideCompletion";
  */
 const overrideCompletion = beginContext((completionSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$J, {
+        swarm$1.loggerService.log(METHOD_NAME$I, {
             completionSchema,
         });
     return swarm$1.completionSchemaService.override(completionSchema.completionName, completionSchema);
 });
 
-const METHOD_NAME$I = "function.test.overrideEmbeding";
+const METHOD_NAME$H = "function.test.overrideEmbeding";
 /**
  * Overrides an existing embedding schema in the swarm system with a new or partial schema.
  * This function updates the configuration of an embedding mechanism identified by its `embeddingName`, applying the provided schema properties.
@@ -18115,13 +18166,13 @@ const METHOD_NAME$I = "function.test.overrideEmbeding";
  */
 const overrideEmbeding = beginContext((embeddingSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$I, {
+        swarm$1.loggerService.log(METHOD_NAME$H, {
             embeddingSchema,
         });
     return swarm$1.embeddingSchemaService.override(embeddingSchema.embeddingName, embeddingSchema);
 });
 
-const METHOD_NAME$H = "function.test.overridePolicy";
+const METHOD_NAME$G = "function.test.overridePolicy";
 /**
  * Overrides an existing policy schema in the swarm system with a new or partial schema.
  * This function updates the configuration of a policy identified by its `policyName`, applying the provided schema properties.
@@ -18145,13 +18196,13 @@ const METHOD_NAME$H = "function.test.overridePolicy";
  */
 const overridePolicy = beginContext((policySchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$H, {
+        swarm$1.loggerService.log(METHOD_NAME$G, {
             policySchema,
         });
     return swarm$1.policySchemaService.override(policySchema.policyName, policySchema);
 });
 
-const METHOD_NAME$G = "function.test.overrideState";
+const METHOD_NAME$F = "function.test.overrideState";
 /**
  * Overrides an existing state schema in the swarm system with a new or partial schema.
  * This function updates the configuration of a state identified by its `stateName`, applying the provided schema properties.
@@ -18176,13 +18227,13 @@ const METHOD_NAME$G = "function.test.overrideState";
  */
 const overrideState = beginContext((stateSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$G, {
+        swarm$1.loggerService.log(METHOD_NAME$F, {
             stateSchema,
         });
     return swarm$1.stateSchemaService.override(stateSchema.stateName, stateSchema);
 });
 
-const METHOD_NAME$F = "function.test.overrideStorage";
+const METHOD_NAME$E = "function.test.overrideStorage";
 /**
  * Overrides an existing storage schema in the swarm system with a new or partial schema.
  * This function updates the configuration of a storage identified by its `storageName`, applying the provided schema properties.
@@ -18208,13 +18259,13 @@ const METHOD_NAME$F = "function.test.overrideStorage";
  */
 const overrideStorage = beginContext((storageSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$F, {
+        swarm$1.loggerService.log(METHOD_NAME$E, {
             storageSchema,
         });
     return swarm$1.storageSchemaService.override(storageSchema.storageName, storageSchema);
 });
 
-const METHOD_NAME$E = "function.test.overrideSwarm";
+const METHOD_NAME$D = "function.test.overrideSwarm";
 /**
  * Overrides an existing swarm schema in the swarm system with a new or partial schema.
  * This function updates the configuration of a swarm identified by its `swarmName`, applying the provided schema properties.
@@ -18238,13 +18289,13 @@ const METHOD_NAME$E = "function.test.overrideSwarm";
  */
 const overrideSwarm = beginContext((swarmSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$E, {
+        swarm$1.loggerService.log(METHOD_NAME$D, {
             swarmSchema,
         });
     return swarm$1.swarmSchemaService.override(swarmSchema.swarmName, swarmSchema);
 });
 
-const METHOD_NAME$D = "function.test.overrideTool";
+const METHOD_NAME$C = "function.test.overrideTool";
 /**
  * Overrides an existing tool schema in the swarm system with a new or partial schema.
  * This function updates the configuration of a tool identified by its `toolName`, applying the provided schema properties.
@@ -18268,13 +18319,13 @@ const METHOD_NAME$D = "function.test.overrideTool";
  */
 const overrideTool = beginContext((toolSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$D, {
+        swarm$1.loggerService.log(METHOD_NAME$C, {
             toolSchema,
         });
     return swarm$1.toolSchemaService.override(toolSchema.toolName, toolSchema);
 });
 
-const METHOD_NAME$C = "function.test.overrideMCP";
+const METHOD_NAME$B = "function.test.overrideMCP";
 /**
  * Overrides an existing MCP (Model Context Protocol) schema with a new or partial schema.
  * @param mcpSchema - The MCP schema containing the name and optional properties to override.
@@ -18282,13 +18333,13 @@ const METHOD_NAME$C = "function.test.overrideMCP";
  */
 const overrideMCP = beginContext((mcpSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$C, {
+        swarm$1.loggerService.log(METHOD_NAME$B, {
             mcpSchema,
         });
     return swarm$1.mcpSchemaService.override(mcpSchema.mcpName, mcpSchema);
 });
 
-const METHOD_NAME$B = "function.test.overrideWiki";
+const METHOD_NAME$A = "function.test.overrideWiki";
 /**
  * Overrides an existing wiki schema in the swarm system with a new or partial schema.
  * This function updates the configuration of a wiki identified by its `wikiName`, applying the provided schema properties.
@@ -18312,7 +18363,7 @@ const METHOD_NAME$B = "function.test.overrideWiki";
  */
 const overrideWiki = beginContext((wikiSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$B, {
+        swarm$1.loggerService.log(METHOD_NAME$A, {
             wikiSchema,
         });
     return swarm$1.wikiSchemaService.override(wikiSchema.wikiName, wikiSchema);
@@ -18327,7 +18378,7 @@ const overrideWiki = beginContext((wikiSchema) => {
  * @description Method name for the overrideCompute operation.
  * @private
  */
-const METHOD_NAME$A = "function.test.overrideCompute";
+const METHOD_NAME$z = "function.test.overrideCompute";
 /**
  * @function overrideCompute
  * @description Overrides an existing compute schema with provided partial updates.
@@ -18336,13 +18387,13 @@ const METHOD_NAME$A = "function.test.overrideCompute";
  */
 const overrideCompute = beginContext((computeSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$A, {
+        swarm$1.loggerService.log(METHOD_NAME$z, {
             computeSchema,
         });
     return swarm$1.computeSchemaService.override(computeSchema.computeName, computeSchema);
 });
 
-const METHOD_NAME$z = "function.other.markOnline";
+const METHOD_NAME$y = "function.other.markOnline";
 /**
  * Marks a client as online in the specified swarm.
  *
@@ -18354,16 +18405,16 @@ const METHOD_NAME$z = "function.other.markOnline";
 const markOnline = async (clientId, swarmName) => {
     // Log the operation if logging is enabled in the global configuration
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm.loggerService.log(METHOD_NAME$z, {
+        swarm.loggerService.log(METHOD_NAME$y, {
             clientId,
         });
     // Validate the swarm name
-    swarm.swarmValidationService.validate(swarmName, METHOD_NAME$z);
+    swarm.swarmValidationService.validate(swarmName, METHOD_NAME$y);
     // Run the operation in the method context
     return await MethodContextService.runInContext(async () => {
-        await swarm.aliveService.markOnline(clientId, swarmName, METHOD_NAME$z);
+        await swarm.aliveService.markOnline(clientId, swarmName, METHOD_NAME$y);
     }, {
-        methodName: METHOD_NAME$z,
+        methodName: METHOD_NAME$y,
         agentName: "",
         policyName: "",
         stateName: "",
@@ -18375,7 +18426,7 @@ const markOnline = async (clientId, swarmName) => {
     });
 };
 
-const METHOD_NAME$y = "function.other.markOffline";
+const METHOD_NAME$x = "function.other.markOffline";
 /**
  * Marks a client as offline in the specified swarm.
  *
@@ -18390,14 +18441,14 @@ const METHOD_NAME$y = "function.other.markOffline";
  */
 const markOffline = async (clientId, swarmName) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm.loggerService.log(METHOD_NAME$y, {
+        swarm.loggerService.log(METHOD_NAME$x, {
             clientId,
         });
-    swarm.swarmValidationService.validate(swarmName, METHOD_NAME$y);
+    swarm.swarmValidationService.validate(swarmName, METHOD_NAME$x);
     return await MethodContextService.runInContext(async () => {
-        await swarm.aliveService.markOffline(clientId, swarmName, METHOD_NAME$y);
+        await swarm.aliveService.markOffline(clientId, swarmName, METHOD_NAME$x);
     }, {
-        methodName: METHOD_NAME$y,
+        methodName: METHOD_NAME$x,
         agentName: "",
         policyName: "",
         stateName: "",
@@ -18410,7 +18461,7 @@ const markOffline = async (clientId, swarmName) => {
 };
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$x = "function.commit.commitSystemMessage";
+const METHOD_NAME$w = "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.
@@ -18429,20 +18480,20 @@ const METHOD_NAME$x = "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$x, {
+        swarm$1.loggerService.log(METHOD_NAME$w, {
             content,
             clientId,
             agentName,
         });
     // Validate the agent exists
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$x);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$w);
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$x);
+    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$x);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$w);
     // Check if the current agent matches the provided agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$x, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$w, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "commitSystemMessage" skipped due to the agent change', {
@@ -18453,10 +18504,10 @@ const commitSystemMessage = beginContext(async (content, clientId, agentName) =>
         return;
     }
     // Commit the system message via SessionPublicService
-    await swarm$1.sessionPublicService.commitSystemMessage(content, METHOD_NAME$x, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitSystemMessage(content, METHOD_NAME$w, clientId, swarmName);
 });
 
-const METHOD_NAME$w = "function.commit.commitSystemMessage";
+const METHOD_NAME$v = "function.commit.commitSystemMessage";
 /**
  * Commits a user message to the active agent's history in a swarm session without triggering a response.
  *
@@ -18475,19 +18526,19 @@ const METHOD_NAME$w = "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$w, {
+        swarm$1.loggerService.log(METHOD_NAME$v, {
             content,
             clientId,
             agentName,
             mode,
         });
     // Validate the agent, session, and swarm to ensure they exist and are accessible
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$w);
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$w);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$v);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$v);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$w);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$v);
     // Check if the specified agent is still the active agent in the swarm session
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$w, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$v, clientId, swarmName);
     if (currentAgentName !== agentName) {
         // Log a skip message if the agent has changed during the operation
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
@@ -18500,18 +18551,18 @@ const commitUserMessage = beginContext(async (content, mode, clientId, agentName
     }
     if (payload) {
         return await PayloadContextService.runInContext(async () => {
-            await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$w, clientId, swarmName);
+            await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$v, 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$w, clientId, swarmName);
+    return await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$v, clientId, swarmName);
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$v = "function.commit.commitSystemMessageForce";
+const METHOD_NAME$u = "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.
@@ -18530,20 +18581,20 @@ const METHOD_NAME$v = "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$v, {
+        swarm$1.loggerService.log(METHOD_NAME$u, {
             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$u);
     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$u);
     // Commit the system message via SessionPublicService without agent checks
-    await swarm$1.sessionPublicService.commitSystemMessage(content, METHOD_NAME$v, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitSystemMessage(content, METHOD_NAME$u, clientId, swarmName);
 });
 
-const METHOD_NAME$u = "function.commit.commitSystemMessage";
+const METHOD_NAME$t = "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.
  *
@@ -18561,29 +18612,29 @@ const METHOD_NAME$u = "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$u, {
+        swarm$1.loggerService.log(METHOD_NAME$t, {
             content,
             clientId,
             mode,
         });
     // Validate the session and swarm to ensure they exist and are accessible
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$u);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$t);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$u);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$t);
     if (payload) {
         return await PayloadContextService.runInContext(async () => {
-            await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$u, clientId, swarmName);
+            await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$t, 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$u, clientId, swarmName);
+    return await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$t, clientId, swarmName);
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$t = "function.commit.commitAssistantMessage";
+const METHOD_NAME$s = "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.
@@ -18601,20 +18652,20 @@ const METHOD_NAME$t = "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$t, {
+        swarm$1.loggerService.log(METHOD_NAME$s, {
             content,
             clientId,
             agentName,
         });
     // Validate the agent exists
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$t);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$s);
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$t);
+    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$t);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$s);
     // Check if the current agent matches the provided agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$t, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$s, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "commitAssistantMessage" skipped due to the agent change', {
@@ -18625,11 +18676,11 @@ const commitAssistantMessage = beginContext(async (content, clientId, agentName)
         return;
     }
     // Commit the assistant message via SessionPublicService
-    await swarm$1.sessionPublicService.commitAssistantMessage(content, METHOD_NAME$t, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitAssistantMessage(content, METHOD_NAME$s, clientId, swarmName);
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$s = "function.commit.commitAssistantMessageForce";
+const METHOD_NAME$r = "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.
@@ -18648,21 +18699,21 @@ const METHOD_NAME$s = "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$s, {
+        swarm$1.loggerService.log(METHOD_NAME$r, {
             content,
             clientId,
         });
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$s);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$r);
     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$r);
     // Commit the assistant message via SessionPublicService without agent checks
-    await swarm$1.sessionPublicService.commitAssistantMessage(content, METHOD_NAME$s, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitAssistantMessage(content, METHOD_NAME$r, clientId, swarmName);
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$r = "function.commit.cancelOutput";
+const METHOD_NAME$q = "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.
@@ -18678,19 +18729,19 @@ const METHOD_NAME$r = "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$r, {
+        swarm$1.loggerService.log(METHOD_NAME$q, {
             clientId,
             agentName,
         });
     // Validate the agent exists
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$r);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$q);
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$r);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$q);
     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$q);
     // Check if the current agent matches the provided agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$r, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$q, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "cancelOutput" skipped due to the agent change', {
@@ -18701,11 +18752,11 @@ const cancelOutput = beginContext(async (clientId, agentName) => {
         return;
     }
     // Perform the output cancellation via SwarmPublicService
-    await swarm$1.swarmPublicService.cancelOutput(METHOD_NAME$r, clientId, swarmName);
+    await swarm$1.swarmPublicService.cancelOutput(METHOD_NAME$q, clientId, swarmName);
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$q = "function.commit.cancelOutputForce";
+const METHOD_NAME$p = "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.
@@ -18721,61 +18772,17 @@ const METHOD_NAME$q = "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$q, {
-            clientId,
-        });
-    // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$q);
-    const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$q);
-    // Perform the output cancellation via SwarmPublicService without agent checks
-    await swarm$1.swarmPublicService.cancelOutput(METHOD_NAME$q, clientId, swarmName);
-});
-
-/** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$p = "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.
- * Runs within a beginContext wrapper for execution context management, logging operations via LoggerService.
- * Integrates with AgentValidationService (agent validation), SessionValidationService (session and swarm retrieval),
- * SwarmValidationService (swarm validation), SwarmPublicService (agent retrieval), SessionPublicService (tool execution stop),
- * ToolValidationService (tool context), and LoggerService (logging). Complements functions like commitFlush by controlling tool flow rather than clearing history.
- *
- * @param {string} clientId - The ID of the client associated with the session, validated against active sessions.
- * @param {string} agentName - The name of the agent whose next tool execution is to be stopped, validated against registered agents.
- * @returns {Promise<void>} A promise that resolves when the tool stop is committed or skipped (e.g., agent mismatch).
- * @throws {Error} If agent, session, or swarm validation fails, propagated from respective validation services.
- */
-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$p, {
             clientId,
-            agentName,
         });
-    // Validate the agent exists
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$p);
     // Validate the session exists and retrieve the associated swarm
     swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$p);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
     swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$p);
-    // Check if the current agent matches the provided agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$p, clientId, swarmName);
-    if (currentAgentName !== agentName) {
-        GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-            swarm$1.loggerService.log('function "commitStopTools" skipped due to the agent change', {
-                currentAgentName,
-                agentName,
-                clientId,
-            });
-        return;
-    }
-    // Commit the stop of the next tool execution via SessionPublicService
-    await swarm$1.sessionPublicService.commitStopTools(METHOD_NAME$p, clientId, swarmName);
+    // Perform the output cancellation via SwarmPublicService without agent checks
+    await swarm$1.swarmPublicService.cancelOutput(METHOD_NAME$p, clientId, swarmName);
 });
 
 /** @private Constant defining the method name for logging and validation context */