agent-swarm-kit 1.1.78 → 1.1.80

package/build/index.cjs

@@ -70,6 +70,7 @@ const schemaServices$1 = {
     mcpSchemaService: Symbol('mcpSchemaService'),
     computeSchemaService: Symbol('computeSchemaService'),
     pipelineSchemaService: Symbol('pipelineSchemaService'),
+    navigationSchemaService: Symbol('navigationSchemaService'),
 };
 const metaServices$1 = {
     agentMetaService: Symbol('agentMetaService'),
@@ -4145,10 +4146,10 @@ class ClientAgent {
                 }
                 return false;
             })
-                .sort(({ function: { name: a } }, { function: { name: b } }) => {
-                const aStarts = a.startsWith("navigate_to_");
-                const bStarts = b.startsWith("navigate_to_");
-                return aStarts === bStarts ? 0 : aStarts ? 1 : -1;
+                .sort(({ toolName: a }, { toolName: b }) => {
+                const aStarts = swarm$1.navigationSchemaService.hasTool(a);
+                const bStarts = swarm$1.navigationSchemaService.hasTool(b);
+                return aStarts === bStarts ? 0 : aStarts ? -1 : 1;
             });
         }
         return agentToolList
@@ -17848,6 +17849,60 @@ class ExecutionValidationService {
     }
 }
 
+/**
+ * @class NavigationSchemaService
+ * Manages a collection of navigation tool names using a Set for efficient registration and lookup.
+ * Injects LoggerService via dependency injection for logging operations.
+ * Supports agent navigation functionality within the swarm system by tracking available navigation tools.
+ */
+class NavigationSchemaService {
+    constructor() {
+        /**
+         * @private
+         * @readonly
+         * @type {LoggerService}
+         * Logger service instance, injected via dependency injection, for logging navigation schema operations.
+         * Used in register and hasTool methods when GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO is true.
+         */
+        this.loggerService = inject(TYPES.loggerService);
+        /**
+         * @private
+         * @type {Set<ToolName>}
+         * Set for storing navigation tool names, ensuring uniqueness and efficient lookup.
+         * Updated via the register method and queried via the hasTool method.
+         */
+        this._navigationToolNameSet = new Set();
+        /**
+         * Registers a navigation tool name in the internal Set.
+         * Logs the registration operation via LoggerService if GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO is true.
+         * @param {ToolName} toolName - The name of the navigation tool to register, sourced from Agent.interface.
+         * @returns {Promise<void>} A promise that resolves when the tool name is registered.
+         * @async
+         */
+        this.register = (toolName) => {
+            GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO &&
+                this.loggerService.info(`navigationSchemaService register`, {
+                    toolName,
+                });
+            this._navigationToolNameSet.add(toolName);
+        };
+        /**
+         * Checks if a navigation tool name exists in the internal Set.
+         * Logs the lookup operation via LoggerService if GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO is true.
+         * @param {ToolName} toolName - The name of the navigation tool to check, sourced from Agent.interface.
+         * @returns {Promise<boolean>} A promise that resolves to true if the tool name exists, false otherwise.
+         * @async
+         */
+        this.hasTool = (toolName) => {
+            GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO &&
+                this.loggerService.info(`navigationSchemaService hasTool`, {
+                    toolName,
+                });
+            return this._navigationToolNameSet.has(toolName);
+        };
+    }
+}
+
 {
     provide(TYPES.docService, () => new DocService());
     provide(TYPES.busService, () => new BusService());
@@ -17889,6 +17944,7 @@ class ExecutionValidationService {
     provide(TYPES.mcpSchemaService, () => new MCPSchemaService());
     provide(TYPES.computeSchemaService, () => new ComputeSchemaService());
     provide(TYPES.pipelineSchemaService, () => new PipelineSchemaService());
+    provide(TYPES.navigationSchemaService, () => new NavigationSchemaService());
 }
 {
     provide(TYPES.agentPublicService, () => new AgentPublicService());
@@ -17967,6 +18023,7 @@ const schemaServices = {
     mcpSchemaService: inject(TYPES.mcpSchemaService),
     computeSchemaService: inject(TYPES.computeSchemaService),
     pipelineSchemaService: inject(TYPES.pipelineSchemaService),
+    navigationSchemaService: inject(TYPES.navigationSchemaService),
 };
 const publicServices = {
     agentPublicService: inject(TYPES.agentPublicService),
@@ -18562,7 +18619,45 @@ async function executeForce(content, clientId) {
     return await executeForceInternal(content, clientId);
 }
 
-const METHOD_NAME$13 = "function.template.navigateToTriageAgent";
+/** @private Constant defining the method name for logging and validation context */
+const METHOD_NAME$13 = "function.commit.commitStopToolsForce";
+/**
+ * Function implementation
+ */
+const commitStopToolsForceInternal = beginContext(async (clientId) => {
+    // Log the stop tools attempt if enabled
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
+        swarm$1.loggerService.log(METHOD_NAME$13, {
+            clientId,
+            METHOD_NAME: METHOD_NAME$13,
+        });
+    // Validate the session exists and retrieve the associated swarm
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$13);
+    const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
+    // Validate the swarm configuration
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$13);
+    // Commit the stop of the next tool execution via SessionPublicService without agent checks
+    await swarm$1.sessionPublicService.commitStopTools(METHOD_NAME$13, clientId, swarmName);
+});
+/**
+ * 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.
+ * Runs within a beginContext wrapper for execution context management, logging operations via LoggerService.
+ * Integrates with SessionValidationService (session and swarm retrieval), SwarmValidationService (swarm validation),
+ * SessionPublicService (tool execution stop), ToolValidationService (tool context), and LoggerService (logging).
+ * Unlike commitStopTools, this function skips agent validation and active agent checks, providing a more aggressive stop mechanism,
+ * analogous to commitFlushForce vs. commitFlush.
+ *
+ * @param {string} clientId - The ID of the client associated with the session, validated against active sessions.
+ * @param {string} agentName - The name of the agent (unused in this implementation, included for interface consistency with commitStopTools).
+ * @returns {Promise<void>} A promise that resolves when the tool stop is committed.
+ * @throws {Error} If session or swarm validation fails, propagated from respective validation services.
+ */
+async function commitStopToolsForce(clientId) {
+    return await commitStopToolsForceInternal(clientId);
+}
+
+const METHOD_NAME$12 = "function.template.navigateToTriageAgent";
 /**
  * Will send tool output directly to the model without any additions
  */
@@ -18613,13 +18708,14 @@ const createNavigateToTriageAgent = ({ flushMessage, lastMessage: lastMessageFn
      */
     return beginContext(async (toolId, clientId) => {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-            swarm$1.loggerService.log(METHOD_NAME$13, {
+            swarm$1.loggerService.log(METHOD_NAME$12, {
                 clientId,
                 toolId,
             });
         const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
         const { defaultAgent } = swarm$1.swarmSchemaService.get(swarmName);
         const lastAgent = await getAgentName(clientId);
+        await commitStopToolsForce(clientId);
         if (await functoolsKit.not(hasNavigation(clientId, defaultAgent))) {
             const lastMessage = await getLastUserMessage(clientId);
             await changeToDefaultAgent(clientId);
@@ -18645,7 +18741,7 @@ const createNavigateToTriageAgent = ({ flushMessage, lastMessage: lastMessageFn
     });
 };
 
-const METHOD_NAME$12 = "function.navigate.changeToAgent";
+const METHOD_NAME$11 = "function.navigate.changeToAgent";
 /**
  * Creates a change agent function with time-to-live (TTL) and queuing capabilities.
  *
@@ -18669,7 +18765,7 @@ const createChangeToAgent = functoolsKit.memoize(([clientId]) => `${clientId}`,
     }));
     {
         // Dispose of the current agent's resources and set up the new agent
-        const agentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$12, clientId, swarmName);
+        const agentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$11, 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));
@@ -18697,16 +18793,16 @@ const createGc$2 = functoolsKit.singleshot(async () => {
 const changeToAgentInternal = 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$12, {
+        swarm$1.loggerService.log(METHOD_NAME$11, {
             agentName,
             clientId,
         });
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     {
         // Validate session, agent, and dependencies
-        swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$12);
-        swarm$1.agentValidationService.validate(agentName, METHOD_NAME$12);
-        const activeAgent = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$12, clientId, swarmName);
+        swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$11);
+        swarm$1.agentValidationService.validate(agentName, METHOD_NAME$11);
+        const activeAgent = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$11, clientId, swarmName);
         if (!swarm$1.agentValidationService.hasDependency(activeAgent, agentName)) {
             console.error(`agent-swarm missing dependency detected for activeAgent=${activeAgent} dependencyAgent=${agentName}`);
         }
@@ -18724,7 +18820,7 @@ const changeToAgentInternal = beginContext(async (agentName, clientId) => {
     // Execute the agent change with TTL and queuing
     const run = await createChangeToAgent(clientId);
     createGc$2();
-    return await run(METHOD_NAME$12, agentName, swarmName);
+    return await run(METHOD_NAME$11, agentName, swarmName);
 });
 /**
  * Changes the active agent for a given client session in a swarm.
@@ -18744,7 +18840,7 @@ async function changeToAgent(agentName, clientId) {
     return await changeToAgentInternal(agentName, clientId);
 }
 
-const METHOD_NAME$11 = "function.template.navigateToAgent";
+const METHOD_NAME$10 = "function.template.navigateToAgent";
 /**
  * Will send tool output directly to the model without any additions
  */
@@ -18810,12 +18906,13 @@ 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$11, {
+            swarm$1.loggerService.log(METHOD_NAME$10, {
                 clientId,
                 toolId,
             });
         const lastMessage = await getLastUserMessage(clientId);
         const lastAgent = await getAgentName(clientId);
+        await commitStopToolsForce(clientId);
         if (await functoolsKit.and(functoolsKit.not(hasNavigation(clientId, agentName)), Promise.resolve(!emitMessage))) {
             await commitToolOutputForce(toolId, typeof toolOutput === "string"
                 ? toolOutput
@@ -18843,14 +18940,14 @@ const createNavigateToAgent = ({ executeMessage = DEFAULT_EXECUTE_MESSAGE, emitM
     });
 };
 
-const METHOD_NAME$10 = "function.setup.addTool";
+const METHOD_NAME$$ = "function.setup.addTool";
 /**
  * Function implementation
  */
 const addToolInternal = 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$10, {
+        swarm$1.loggerService.log(METHOD_NAME$$, {
             toolSchema,
         });
     // Register the tool in the validation and schema services
@@ -18885,21 +18982,19 @@ function addTool(toolSchema) {
  * Adds navigation functionality to an agent by creating a tool that allows navigation to a specified agent.
  * @module addAgentNavigation
  */
-const METHOD_NAME$$ = "function.alias.addAgentNavigation";
-const DEFAULT_SKIP_PLACEHOLDER$1 = "Navigation canceled";
+const METHOD_NAME$_ = "function.alias.addAgentNavigation";
 /**
  * Function implementation
  */
-const addAgentNavigationInternal = beginContext(({ toolName, docNote, description, navigateTo, skipPlaceholder = DEFAULT_SKIP_PLACEHOLDER$1, ...navigateProps }) => {
-    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$$);
+const addAgentNavigationInternal = beginContext(({ toolName, docNote, description, navigateTo, ...navigateProps }) => {
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$_);
     const navigate = createNavigateToAgent(navigateProps);
-    return addTool({
+    const toolSchema = addTool({
         toolName,
         docNote,
-        call: async ({ toolId, clientId, isLast }) => {
-            if (!isLast) {
-                await commitToolOutputForce(toolId, skipPlaceholder, clientId);
-                return;
+        call: async ({ toolId, clientId, toolCalls }) => {
+            if (toolCalls.length > 1) {
+                console.error("agent-swarm addAgentNavigation model called multiple tools within navigation execution");
             }
             await navigate(toolId, clientId, navigateTo);
         },
@@ -18914,6 +19009,8 @@ const addAgentNavigationInternal = beginContext(({ toolName, docNote, descriptio
             },
         },
     });
+    swarm$1.navigationSchemaService.register(toolName);
+    return toolSchema;
 });
 /**
  * Creates and registers a navigation tool for an agent to navigate to another specified agent.
@@ -18934,21 +19031,19 @@ function addAgentNavigation(params) {
  * Adds triage navigation functionality to an agent by creating a tool that facilitates navigation to a triage agent.
  * @module addTriageNavigation
  */
-const METHOD_NAME$_ = "function.alias.addTriageNavigation";
-const DEFAULT_SKIP_PLACEHOLDER = "Navigation canceled";
+const METHOD_NAME$Z = "function.alias.addTriageNavigation";
 /**
  * Function implementation
  */
-const addTriageNavigationInternal = beginContext(({ toolName, docNote, description, skipPlaceholder = DEFAULT_SKIP_PLACEHOLDER, ...navigateProps }) => {
-    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$_);
+const addTriageNavigationInternal = beginContext(({ toolName, docNote, description, ...navigateProps }) => {
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$Z);
     const navigate = createNavigateToTriageAgent(navigateProps);
-    return addTool({
+    const toolSchema = addTool({
         toolName,
         docNote,
-        call: async ({ toolId, clientId, isLast }) => {
-            if (!isLast) {
-                await commitToolOutputForce(toolId, skipPlaceholder, clientId);
-                return;
+        call: async ({ toolId, clientId, toolCalls }) => {
+            if (toolCalls.length > 1) {
+                console.error("agent-swarm addTriageNavigation model called multiple tools within navigation execution");
             }
             await navigate(toolId, clientId);
         },
@@ -18963,6 +19058,8 @@ const addTriageNavigationInternal = beginContext(({ toolName, docNote, descripti
             },
         },
     });
+    swarm$1.navigationSchemaService.register(toolName);
+    return toolSchema;
 });
 /**
  * Creates and registers a triage navigation tool for an agent to navigate to a triage agent.
@@ -18979,13 +19076,13 @@ function addTriageNavigation(params) {
 }
 
 /** @constant {string} METHOD_NAME - The name of the method used for logging */
-const METHOD_NAME$Z = "function.setup.addWiki";
+const METHOD_NAME$Y = "function.setup.addWiki";
 /**
  * Function implementation
  */
 const addWikiInternal = beginContext((wikiSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$Z, {
+        swarm$1.loggerService.log(METHOD_NAME$Y, {
             wikiSchema,
         });
     swarm$1.wikiValidationService.addWiki(wikiSchema.wikiName, wikiSchema);
@@ -19072,14 +19169,14 @@ const mapAgentSchema = ({ system, systemDynamic, systemStatic, ...schema }) => r
         : systemDynamic,
 });
 
-const METHOD_NAME$Y = "function.setup.addAgent";
+const METHOD_NAME$X = "function.setup.addAgent";
 /**
  * Function implementation
  */
 const addAgentInternal = beginContext((publicAgentSchema) => {
     // 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, {
             agentSchema: publicAgentSchema,
         });
     const agentSchema = mapAgentSchema(publicAgentSchema);
@@ -19109,14 +19206,14 @@ function addAgent(agentSchema) {
     return addAgentInternal(agentSchema);
 }
 
-const METHOD_NAME$X = "function.setup.addCompletion";
+const METHOD_NAME$W = "function.setup.addCompletion";
 /**
  * Function implementation
  */
 const addCompletionInternal = 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$X, {
+        swarm$1.loggerService.log(METHOD_NAME$W, {
             completionSchema,
         });
     // Register the completion in the validation and schema services
@@ -19145,14 +19242,14 @@ function addCompletion(completionSchema) {
     return addCompletionInternal(completionSchema);
 }
 
-const METHOD_NAME$W = "function.setup.addSwarm";
+const METHOD_NAME$V = "function.setup.addSwarm";
 /**
  * Function implementation
  */
 const addSwarmInternal = 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$W, {
+        swarm$1.loggerService.log(METHOD_NAME$V, {
             swarmSchema,
         });
     // Register the swarm in the validation and schema services
@@ -19181,13 +19278,13 @@ function addSwarm(swarmSchema) {
     return addSwarmInternal(swarmSchema);
 }
 
-const METHOD_NAME$V = "function.setup.addMCP";
+const METHOD_NAME$U = "function.setup.addMCP";
 /**
  * Function implementation
  */
 const addMCPInternal = beginContext((mcpSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$V, {
+        swarm$1.loggerService.log(METHOD_NAME$U, {
             mcpSchema,
         });
     swarm$1.mcpValidationService.addMCP(mcpSchema.mcpName, mcpSchema);
@@ -19203,14 +19300,14 @@ function addMCP(mcpSchema) {
     return addMCPInternal(mcpSchema);
 }
 
-const METHOD_NAME$U = "function.setup.addState";
+const METHOD_NAME$T = "function.setup.addState";
 /**
  * Function implementation
  */
 const addStateInternal = 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$U, {
+        swarm$1.loggerService.log(METHOD_NAME$T, {
             stateSchema,
         });
     // Register the policy with StateValidationService for runtime validation
@@ -19248,14 +19345,14 @@ function addState(stateSchema) {
     return addStateInternal(stateSchema);
 }
 
-const METHOD_NAME$T = "function.setup.addEmbedding";
+const METHOD_NAME$S = "function.setup.addEmbedding";
 /**
  * Function implementation
  */
 const addEmbeddingInternal = 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$T, {
+        swarm$1.loggerService.log(METHOD_NAME$S, {
             embeddingSchema,
         });
     // Register the embedding in the validation and schema services
@@ -19284,14 +19381,14 @@ function addEmbedding(embeddingSchema) {
     return addEmbeddingInternal(embeddingSchema);
 }
 
-const METHOD_NAME$S = "function.setup.addStorage";
+const METHOD_NAME$R = "function.setup.addStorage";
 /**
  * Function implementation
  */
 const addStorageInternal = 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$S, {
+        swarm$1.loggerService.log(METHOD_NAME$R, {
             storageSchema,
         });
     // Register the storage in the validation and schema services
@@ -19329,14 +19426,14 @@ function addStorage(storageSchema) {
 }
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$R = "function.setup.addPolicy";
+const METHOD_NAME$Q = "function.setup.addPolicy";
 /**
  * Function implementation
  */
 const addPolicyInternal = beginContext((policySchema) => {
     // Log the policy addition attempt if enabled
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$R, {
+        swarm$1.loggerService.log(METHOD_NAME$Q, {
             policySchema,
         });
     // Register the policy with PolicyValidationService for runtime validation
@@ -19397,13 +19494,13 @@ function addCompute(computeSchema) {
  * @description Method name for the addPipeline operation.
  * @private
  */
-const METHOD_NAME$Q = "function.setup.addPipeline";
+const METHOD_NAME$P = "function.setup.addPipeline";
 /**
  * Function implementation
  */
 const addPipelineInternal = beginContext((pipelineSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$Q, {
+        swarm$1.loggerService.log(METHOD_NAME$P, {
             pipelineSchema,
         });
     swarm$1.pipelineValidationService.addPipeline(pipelineSchema.pipelineName, pipelineSchema);
@@ -19420,13 +19517,13 @@ function addPipeline(pipelineSchema) {
     return addPipelineInternal(pipelineSchema);
 }
 
-const METHOD_NAME$P = "function.test.overrideAgent";
+const METHOD_NAME$O = "function.test.overrideAgent";
 /**
  * Function implementation
  */
 const overrideAgentInternal = beginContext((publicAgentSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$P, {
+        swarm$1.loggerService.log(METHOD_NAME$O, {
             agentSchema: publicAgentSchema,
         });
     const agentSchema = mapAgentSchema(publicAgentSchema);
@@ -19457,13 +19554,13 @@ function overrideAgent(agentSchema) {
     return overrideAgentInternal(agentSchema);
 }
 
-const METHOD_NAME$O = "function.test.overrideCompletion";
+const METHOD_NAME$N = "function.test.overrideCompletion";
 /**
  * Function implementation
  */
 const overrideCompletionInternal = beginContext((completionSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$O, {
+        swarm$1.loggerService.log(METHOD_NAME$N, {
             completionSchema,
         });
     return swarm$1.completionSchemaService.override(completionSchema.completionName, completionSchema);
@@ -19493,13 +19590,13 @@ function overrideCompletion(completionSchema) {
     return overrideCompletionInternal(completionSchema);
 }
 
-const METHOD_NAME$N = "function.test.overrideEmbeding";
+const METHOD_NAME$M = "function.test.overrideEmbeding";
 /**
  * Function implementation
  */
 const overrideEmbedingInternal = beginContext((embeddingSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$N, {
+        swarm$1.loggerService.log(METHOD_NAME$M, {
             embeddingSchema,
         });
     return swarm$1.embeddingSchemaService.override(embeddingSchema.embeddingName, embeddingSchema);
@@ -19531,13 +19628,13 @@ function overrideEmbeding(embeddingSchema) {
     return overrideEmbedingInternal(embeddingSchema);
 }
 
-const METHOD_NAME$M = "function.test.overridePolicy";
+const METHOD_NAME$L = "function.test.overridePolicy";
 /**
  * Function implementation
  */
 const overridePolicyInternal = beginContext((policySchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$M, {
+        swarm$1.loggerService.log(METHOD_NAME$L, {
             policySchema,
         });
     return swarm$1.policySchemaService.override(policySchema.policyName, policySchema);
@@ -19567,13 +19664,13 @@ function overridePolicy(policySchema) {
     return overridePolicyInternal(policySchema);
 }
 
-const METHOD_NAME$L = "function.test.overrideState";
+const METHOD_NAME$K = "function.test.overrideState";
 /**
  * Function implementation
  */
 const overrideStateInternal = beginContext((stateSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$L, {
+        swarm$1.loggerService.log(METHOD_NAME$K, {
             stateSchema,
         });
     return swarm$1.stateSchemaService.override(stateSchema.stateName, stateSchema);
@@ -19604,13 +19701,13 @@ function overrideState(stateSchema) {
     return overrideStateInternal(stateSchema);
 }
 
-const METHOD_NAME$K = "function.test.overrideStorage";
+const METHOD_NAME$J = "function.test.overrideStorage";
 /**
  * Function implementation
  */
 const overrideStorageInternal = beginContext((storageSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$K, {
+        swarm$1.loggerService.log(METHOD_NAME$J, {
             storageSchema,
         });
     return swarm$1.storageSchemaService.override(storageSchema.storageName, storageSchema);
@@ -19642,13 +19739,13 @@ function overrideStorage(storageSchema) {
     return overrideStorageInternal(storageSchema);
 }
 
-const METHOD_NAME$J = "function.test.overrideSwarm";
+const METHOD_NAME$I = "function.test.overrideSwarm";
 /**
  * Function implementation
  */
 const overrideSwarmInternal = beginContext((swarmSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$J, {
+        swarm$1.loggerService.log(METHOD_NAME$I, {
             swarmSchema,
         });
     return swarm$1.swarmSchemaService.override(swarmSchema.swarmName, swarmSchema);
@@ -19678,13 +19775,13 @@ function overrideSwarm(swarmSchema) {
     return overrideSwarmInternal(swarmSchema);
 }
 
-const METHOD_NAME$I = "function.test.overrideTool";
+const METHOD_NAME$H = "function.test.overrideTool";
 /**
  * Function implementation
  */
 const overrideToolInternal = beginContext((toolSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$I, {
+        swarm$1.loggerService.log(METHOD_NAME$H, {
             toolSchema,
         });
     return swarm$1.toolSchemaService.override(toolSchema.toolName, toolSchema);
@@ -19714,13 +19811,13 @@ function overrideTool(toolSchema) {
     return overrideToolInternal(toolSchema);
 }
 
-const METHOD_NAME$H = "function.test.overrideMCP";
+const METHOD_NAME$G = "function.test.overrideMCP";
 /**
  * Function implementation
  */
 const overrideMCPInternal = beginContext((mcpSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$H, {
+        swarm$1.loggerService.log(METHOD_NAME$G, {
             mcpSchema,
         });
     return swarm$1.mcpSchemaService.override(mcpSchema.mcpName, mcpSchema);
@@ -19734,13 +19831,13 @@ function overrideMCP(mcpSchema) {
     return overrideMCPInternal(mcpSchema);
 }
 
-const METHOD_NAME$G = "function.test.overrideWiki";
+const METHOD_NAME$F = "function.test.overrideWiki";
 /**
  * Function implementation
  */
 const overrideWikiInternal = beginContext((wikiSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$G, {
+        swarm$1.loggerService.log(METHOD_NAME$F, {
             wikiSchema,
         });
     return swarm$1.wikiSchemaService.override(wikiSchema.wikiName, wikiSchema);
@@ -19779,13 +19876,13 @@ function overrideWiki(wikiSchema) {
  * @description Method name for the overrideCompute operation.
  * @private
  */
-const METHOD_NAME$F = "function.test.overrideCompute";
+const METHOD_NAME$E = "function.test.overrideCompute";
 /**
  * Function implementation
  */
 const overrideComputeInternal = beginContext((computeSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$F, {
+        swarm$1.loggerService.log(METHOD_NAME$E, {
             computeSchema,
         });
     return swarm$1.computeSchemaService.override(computeSchema.computeName, computeSchema);
@@ -19808,13 +19905,13 @@ function overrideCompute(computeSchema) {
  * @description Method name for the overridePipeline operation.
  * @private
  */
-const METHOD_NAME$E = "function.test.overridePipeline";
+const METHOD_NAME$D = "function.test.overridePipeline";
 /**
  * Function implementation
  */
 const overridePipelineInternal = beginContext((pipelineSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$E, {
+        swarm$1.loggerService.log(METHOD_NAME$D, {
             pipelineSchema,
         });
     return swarm$1.pipelineSchemaService.override(pipelineSchema.pipelineName, pipelineSchema);
@@ -19829,23 +19926,23 @@ function overridePipeline(pipelineSchema) {
     return overridePipelineInternal(pipelineSchema);
 }
 
-const METHOD_NAME$D = "function.other.markOnline";
+const METHOD_NAME$C = "function.other.markOnline";
 /**
  * Function implementation
  */
 const markOnlineInternal = 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$D, {
+        swarm.loggerService.log(METHOD_NAME$C, {
             clientId,
         });
     // Validate the swarm name
-    swarm.swarmValidationService.validate(swarmName, METHOD_NAME$D);
+    swarm.swarmValidationService.validate(swarmName, METHOD_NAME$C);
     // Run the operation in the method context
     return await MethodContextService.runInContext(async () => {
-        await swarm.aliveService.markOnline(clientId, swarmName, METHOD_NAME$D);
+        await swarm.aliveService.markOnline(clientId, swarmName, METHOD_NAME$C);
     }, {
-        methodName: METHOD_NAME$D,
+        methodName: METHOD_NAME$C,
         agentName: "",
         policyName: "",
         stateName: "",
@@ -19868,20 +19965,20 @@ async function markOnline(clientId, swarmName) {
     return await markOnlineInternal(clientId, swarmName);
 }
 
-const METHOD_NAME$C = "function.other.markOffline";
+const METHOD_NAME$B = "function.other.markOffline";
 /**
  * Function implementation
  */
 const markOfflineInternal = async (clientId, swarmName) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm.loggerService.log(METHOD_NAME$C, {
+        swarm.loggerService.log(METHOD_NAME$B, {
             clientId,
         });
-    swarm.swarmValidationService.validate(swarmName, METHOD_NAME$C);
+    swarm.swarmValidationService.validate(swarmName, METHOD_NAME$B);
     return await MethodContextService.runInContext(async () => {
-        await swarm.aliveService.markOffline(clientId, swarmName, METHOD_NAME$C);
+        await swarm.aliveService.markOffline(clientId, swarmName, METHOD_NAME$B);
     }, {
-        methodName: METHOD_NAME$C,
+        methodName: METHOD_NAME$B,
         agentName: "",
         policyName: "",
         stateName: "",
@@ -19909,27 +20006,27 @@ async function markOffline(clientId, swarmName) {
 }
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$B = "function.commit.commitSystemMessage";
+const METHOD_NAME$A = "function.commit.commitSystemMessage";
 /**
  * Function implementation
  */
 const commitSystemMessageInternal = beginContext(async (content, clientId, agentName) => {
     // Log the commit attempt if enabled
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$B, {
+        swarm$1.loggerService.log(METHOD_NAME$A, {
             content,
             clientId,
             agentName,
         });
     // Validate the agent exists
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$B);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$A);
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$B);
+    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$B);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$A);
     // Check if the current agent matches the provided agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$B, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$A, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "commitSystemMessage" skipped due to the agent change', {
@@ -19940,7 +20037,7 @@ const commitSystemMessageInternal = beginContext(async (content, clientId, agent
         return;
     }
     // Commit the system message via SessionPublicService
-    await swarm$1.sessionPublicService.commitSystemMessage(content, METHOD_NAME$B, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitSystemMessage(content, METHOD_NAME$A, clientId, swarmName);
 });
 /**
  * Commits a system-generated message to the active agent in the swarm system.
@@ -19961,26 +20058,26 @@ async function commitSystemMessage(content, clientId, agentName) {
     return await commitSystemMessageInternal(content, clientId, agentName);
 }
 
-const METHOD_NAME$A = "function.commit.commitSystemMessage";
+const METHOD_NAME$z = "function.commit.commitSystemMessage";
 /**
  * Function implementation
  */
 const commitUserMessageInternal = 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$A, {
+        swarm$1.loggerService.log(METHOD_NAME$z, {
             content,
             clientId,
             agentName,
             mode,
         });
     // Validate the agent, session, and swarm to ensure they exist and are accessible
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$A);
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$A);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$z);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$z);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$A);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$z);
     // Check if the specified agent is still the active agent in the swarm session
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$A, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$z, clientId, swarmName);
     if (currentAgentName !== agentName) {
         // Log a skip message if the agent has changed during the operation
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
@@ -19993,14 +20090,14 @@ const commitUserMessageInternal = beginContext(async (content, mode, clientId, a
     }
     if (payload) {
         return await PayloadContextService.runInContext(async () => {
-            await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$A, clientId, swarmName);
+            await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$z, 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$A, clientId, swarmName);
+    return await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$z, clientId, swarmName);
 });
 /**
  * Commits a user message to the active agent's history in a swarm session without triggering a response.
@@ -20022,24 +20119,24 @@ async function commitUserMessage(content, mode, clientId, agentName, payload) {
 }
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$z = "function.commit.commitSystemMessageForce";
+const METHOD_NAME$y = "function.commit.commitSystemMessageForce";
 /**
  * Function implementation
  */
 const commitSystemMessageForceInternal = 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$y, {
             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$y);
     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$y);
     // 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$y, clientId, swarmName);
 });
 /**
  * Forcefully commits a system-generated message to a session in the swarm system, without checking the active agent.
@@ -20060,32 +20157,32 @@ async function commitSystemMessageForce(content, clientId) {
     return await commitSystemMessageForceInternal(content, clientId);
 }
 
-const METHOD_NAME$y = "function.commit.commitSystemMessage";
+const METHOD_NAME$x = "function.commit.commitSystemMessage";
 /**
  * Function implementation
  */
 const commitUserMessageForceInternal = 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$y, {
+        swarm$1.loggerService.log(METHOD_NAME$x, {
             content,
             clientId,
             mode,
         });
     // Validate the session and swarm to ensure they exist and are accessible
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$y);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$x);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$y);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$x);
     if (payload) {
         return await PayloadContextService.runInContext(async () => {
-            await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$y, clientId, swarmName);
+            await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$x, 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$y, clientId, swarmName);
+    return await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$x, clientId, swarmName);
 });
 /**
  * Commits a user message to the active agent's history in a swarm session without triggering a response and without checking the active agent.
@@ -20106,27 +20203,27 @@ async function commitUserMessageForce(content, mode, clientId, payload) {
 }
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$x = "function.commit.commitAssistantMessage";
+const METHOD_NAME$w = "function.commit.commitAssistantMessage";
 /**
  * Function implementation
  */
 const commitAssistantMessageInternal = 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 "commitAssistantMessage" skipped due to the agent change', {
@@ -20137,7 +20234,7 @@ const commitAssistantMessageInternal = beginContext(async (content, clientId, ag
         return;
     }
     // Commit the assistant message via SessionPublicService
-    await swarm$1.sessionPublicService.commitAssistantMessage(content, METHOD_NAME$x, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitAssistantMessage(content, METHOD_NAME$w, clientId, swarmName);
 });
 /**
  * Commits an assistant-generated message to the active agent in the swarm system.
@@ -20158,24 +20255,24 @@ async function commitAssistantMessage(content, clientId, agentName) {
 }
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$w = "function.commit.commitAssistantMessageForce";
+const METHOD_NAME$v = "function.commit.commitAssistantMessageForce";
 /**
  * Function implementation
  */
 const commitAssistantMessageForceInternal = beginContext(async (content, clientId) => {
     // 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$v, {
             content,
             clientId,
         });
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$w);
+    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$w);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$v);
     // Commit the assistant message via SessionPublicService without agent checks
-    await swarm$1.sessionPublicService.commitAssistantMessage(content, METHOD_NAME$w, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitAssistantMessage(content, METHOD_NAME$v, clientId, swarmName);
 });
 /**
  * Forcefully commits an assistant-generated message to a session in the swarm system, without checking the active agent.
@@ -20197,26 +20294,26 @@ async function commitAssistantMessageForce(content, clientId) {
 }
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$v = "function.commit.cancelOutput";
+const METHOD_NAME$u = "function.commit.cancelOutput";
 /**
  * Function implementation
  */
 const cancelOutputInternal = beginContext(async (clientId, agentName) => {
     // Log the cancellation attempt if enabled
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$v, {
+        swarm$1.loggerService.log(METHOD_NAME$u, {
             clientId,
             agentName,
         });
     // Validate the agent exists
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$v);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$u);
     // 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);
     // Check if the current agent matches the provided agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$v, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$u, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "cancelOutput" skipped due to the agent change', {
@@ -20227,7 +20324,7 @@ const cancelOutputInternal = beginContext(async (clientId, agentName) => {
         return;
     }
     // Perform the output cancellation via SwarmPublicService
-    await swarm$1.swarmPublicService.cancelOutput(METHOD_NAME$v, clientId, swarmName);
+    await swarm$1.swarmPublicService.cancelOutput(METHOD_NAME$u, clientId, swarmName);
 });
 /**
  * Cancels the awaited output for a specific client and agent by emitting an empty string.
@@ -20246,23 +20343,23 @@ async function cancelOutput(clientId, agentName) {
 }
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$u = "function.commit.cancelOutputForce";
+const METHOD_NAME$t = "function.commit.cancelOutputForce";
 /**
  * Function implementation
  */
 const cancelOutputForceInternal = beginContext(async (clientId) => {
     // 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$t, {
             clientId,
         });
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$u);
+    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$u);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$t);
     // Perform the output cancellation via SwarmPublicService without agent checks
-    await swarm$1.swarmPublicService.cancelOutput(METHOD_NAME$u, clientId, swarmName);
+    await swarm$1.swarmPublicService.cancelOutput(METHOD_NAME$t, clientId, swarmName);
 });
 /**
  * Forcefully cancels the awaited output for a specific client by emitting an empty string, without checking the active agent.
@@ -20281,44 +20378,6 @@ async function cancelOutputForce(clientId) {
     return await cancelOutputForceInternal(clientId);
 }
 
-/** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$t = "function.commit.commitStopToolsForce";
-/**
- * Function implementation
- */
-const commitStopToolsForceInternal = beginContext(async (clientId) => {
-    // Log the stop tools attempt if enabled
-    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$t, {
-            clientId,
-            METHOD_NAME: METHOD_NAME$t,
-        });
-    // Validate the session exists and retrieve the associated swarm
-    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$t);
-    // Commit the stop of the next tool execution via SessionPublicService without agent checks
-    await swarm$1.sessionPublicService.commitStopTools(METHOD_NAME$t, clientId, swarmName);
-});
-/**
- * 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.
- * Runs within a beginContext wrapper for execution context management, logging operations via LoggerService.
- * Integrates with SessionValidationService (session and swarm retrieval), SwarmValidationService (swarm validation),
- * SessionPublicService (tool execution stop), ToolValidationService (tool context), and LoggerService (logging).
- * Unlike commitStopTools, this function skips agent validation and active agent checks, providing a more aggressive stop mechanism,
- * analogous to commitFlushForce vs. commitFlush.
- *
- * @param {string} clientId - The ID of the client associated with the session, validated against active sessions.
- * @param {string} agentName - The name of the agent (unused in this implementation, included for interface consistency with commitStopTools).
- * @returns {Promise<void>} A promise that resolves when the tool stop is committed.
- * @throws {Error} If session or swarm validation fails, propagated from respective validation services.
- */
-async function commitStopToolsForce(clientId) {
-    return await commitStopToolsForceInternal(clientId);
-}
-
 const METHOD_NAME$s = "function.commit.commitToolRequest";
 /**
  * Function implementation
@@ -23360,9 +23419,10 @@ class ChatUtils {
             const handleCleanup = async () => {
                 const now = Date.now();
                 for (const chat of this._chats.values()) {
-                    if (!chat.checkLastActivity(now)) {
-                        await chat.dispose();
+                    if (await chat.checkLastActivity(now)) {
+                        continue;
                     }
+                    await chat.dispose();
                 }
             };
             setInterval(handleCleanup, INACTIVITY_CHECK);