agent-swarm-kit 1.1.128 → 1.1.129

package/build/index.cjs

@@ -4950,26 +4950,26 @@ class ClientOperator {
     }
 }
 
-const METHOD_NAME$1E = "function.commit.commitToolOutput";
+const METHOD_NAME$1F = "function.commit.commitToolOutput";
 /**
  * Function implementation
  */
 const commitToolOutputInternal = beginContext(async (toolId, content, clientId, agentName) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$1E, {
+        swarm$1.loggerService.log(METHOD_NAME$1F, {
             toolId,
             content,
             clientId,
             agentName,
         });
     // Validate the agent, session, and swarm to ensure they exist and are accessible
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1E);
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1E);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1F);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1F);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1E);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1F);
     // Check if the specified agent is still the active agent in the swarm session
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1E, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1F, clientId, swarmName);
     if (currentAgentName !== agentName) {
         // Log a skip message if the agent has changed during the operation
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
@@ -4982,7 +4982,7 @@ const commitToolOutputInternal = beginContext(async (toolId, content, clientId,
         return;
     }
     // Commit the tool output to the session via the session public service
-    await swarm$1.sessionPublicService.commitToolOutput(toolId, content, METHOD_NAME$1E, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitToolOutput(toolId, content, METHOD_NAME$1F, clientId, swarmName);
 });
 /**
  * Commits the output of a tool execution to the active agent in a swarm session.
@@ -5004,7 +5004,7 @@ async function commitToolOutput(toolId, content, clientId, agentName) {
     return await commitToolOutputInternal(toolId, content, clientId, agentName);
 }
 
-const METHOD_NAME$1D = "function.target.execute";
+const METHOD_NAME$1E = "function.target.execute";
 /**
  * Function implementation
  */
@@ -5012,19 +5012,19 @@ const executeInternal = beginContext(async (content, clientId, agentName) => {
     const executionId = functoolsKit.randomString();
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$1D, {
+        swarm$1.loggerService.log(METHOD_NAME$1E, {
             content,
             clientId,
             agentName,
             executionId,
         });
     // Validate the agent, session, and swarm
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1D);
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1D);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1E);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1E);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1D);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1E);
     // Check if the specified agent is still the active agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1D, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1E, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "execute" skipped due to the agent change', {
@@ -5043,7 +5043,7 @@ const executeInternal = beginContext(async (content, clientId, agentName) => {
                 agentName,
                 swarmName,
             });
-            const result = await swarm$1.sessionPublicService.execute(content, "tool", METHOD_NAME$1D, clientId, swarmName);
+            const result = await swarm$1.sessionPublicService.execute(content, "tool", METHOD_NAME$1E, clientId, swarmName);
             isFinished = swarm$1.perfService.endExecution(executionId, clientId, result.length);
             swarm$1.busService.commitExecutionEnd(clientId, {
                 agentName,
@@ -5085,26 +5085,26 @@ async function execute(content, clientId, agentName) {
 }
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$1C = "function.commit.commitFlush";
+const METHOD_NAME$1D = "function.commit.commitFlush";
 /**
  * Function implementation
  */
 const commitFlushInternal = beginContext(async (clientId, agentName) => {
     // Log the flush attempt if enabled
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$1C, {
+        swarm$1.loggerService.log(METHOD_NAME$1D, {
             clientId,
             agentName,
         });
     // Validate the agent exists
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1C);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1D);
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1C);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1D);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1C);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1D);
     // Check if the current agent matches the provided agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1C, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1D, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "commitFlush" skipped due to the agent change', {
@@ -5115,7 +5115,7 @@ const commitFlushInternal = beginContext(async (clientId, agentName) => {
         return;
     }
     // Commit the flush of agent history via SessionPublicService
-    await swarm$1.sessionPublicService.commitFlush(METHOD_NAME$1C, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitFlush(METHOD_NAME$1D, clientId, swarmName);
 });
 /**
  * Commits a flush of agent history for a specific client and agent in the swarm system.
@@ -5134,25 +5134,25 @@ async function commitFlush(clientId, agentName) {
     return await commitFlushInternal(clientId, agentName);
 }
 
-const METHOD_NAME$1B = "function.target.emit";
+const METHOD_NAME$1C = "function.target.emit";
 /**
  * Function implementation
  */
 const emitInternal = beginContext(async (content, clientId, agentName) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$1B, {
+        swarm$1.loggerService.log(METHOD_NAME$1C, {
             content,
             clientId,
             agentName,
         });
     // Validate the agent, session, and swarm
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1B);
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1B);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1C);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1C);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1B);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1C);
     // Check if the specified agent is still the active agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1B, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1C, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "emit" skipped due to the agent change', {
@@ -5163,7 +5163,7 @@ const emitInternal = beginContext(async (content, clientId, agentName) => {
         return;
     }
     // Emit the content directly via the session public service
-    return await swarm$1.sessionPublicService.emit(content, METHOD_NAME$1B, clientId, swarmName);
+    return await swarm$1.sessionPublicService.emit(content, METHOD_NAME$1C, clientId, swarmName);
 });
 /**
  * Emits a string as model output without executing an incoming message, with agent activity validation.
@@ -5185,22 +5185,22 @@ async function emit(content, clientId, agentName) {
     return await emitInternal(content, clientId, agentName);
 }
 
-const METHOD_NAME$1A = "function.common.getAgentName";
+const METHOD_NAME$1B = "function.common.getAgentName";
 /**
  * Function implementation
  */
 const getAgentNameInternal = 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$1A, {
+        swarm$1.loggerService.log(METHOD_NAME$1B, {
             clientId,
         });
     // Validate the session and swarm to ensure they exist and are accessible
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1A);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1B);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1A);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1B);
     // Retrieve the active agent name via the swarm public service
-    return await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1A, clientId, swarmName);
+    return await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1B, clientId, swarmName);
 });
 /**
  * Retrieves the name of the active agent for a given client session in a swarm.
@@ -5221,26 +5221,26 @@ async function getAgentName(clientId) {
 }
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$1z = "function.commit.commitStopTools";
+const METHOD_NAME$1A = "function.commit.commitStopTools";
 /**
  * Function implementation
  */
 const commitStopToolsInternal = beginContext(async (clientId, agentName) => {
     // Log the stop tools attempt if enabled
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$1z, {
+        swarm$1.loggerService.log(METHOD_NAME$1A, {
             clientId,
             agentName,
         });
     // Validate the agent exists
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1z);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1A);
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1z);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1A);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1z);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1A);
     // Check if the current agent matches the provided agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1z, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1A, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "commitStopTools" skipped due to the agent change', {
@@ -5251,7 +5251,7 @@ const commitStopToolsInternal = beginContext(async (clientId, agentName) => {
         return;
     }
     // Commit the stop of the next tool execution via SessionPublicService
-    await swarm$1.sessionPublicService.commitStopTools(METHOD_NAME$1z, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitStopTools(METHOD_NAME$1A, clientId, swarmName);
 });
 /**
  * Prevents the next tool from being executed for a specific client and agent in the swarm system.
@@ -5812,12 +5812,12 @@ class AgentConnectionService {
 }
 
 /** @private Constant defining the method name for logging purposes */
-const METHOD_NAME$1y = "function.common.getPayload";
+const METHOD_NAME$1z = "function.common.getPayload";
 /**
  * Function implementation
  */
 const getPayloadInternal = () => {
-    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$1y);
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$1z);
     if (PayloadContextService.hasContext()) {
         const { payload } = swarm$1.payloadContextService.context;
         return payload;
@@ -18662,7 +18662,7 @@ const swarm = {
 init();
 var swarm$1 = swarm;
 
-const METHOD_NAME$1x = "cli.dumpDocs";
+const METHOD_NAME$1y = "cli.dumpDocs";
 /**
  * Dumps the documentation for the agents and swarms.
  *
@@ -18672,7 +18672,7 @@ const METHOD_NAME$1x = "cli.dumpDocs";
  */
 const dumpDocs = beginContext((prefix = "swarm", dirName = "./docs/chat", PlantUML, sanitizeMarkdown = (t) => t) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$1x, {
+        swarm$1.loggerService.log(METHOD_NAME$1y, {
             dirName,
         });
     if (PlantUML) {
@@ -18682,10 +18682,10 @@ const dumpDocs = beginContext((prefix = "swarm", dirName = "./docs/chat", PlantU
     }
     swarm$1.agentValidationService
         .getAgentList()
-        .forEach((agentName) => swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1x));
+        .forEach((agentName) => swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1y));
     swarm$1.swarmValidationService
         .getSwarmList()
-        .forEach((swarmName) => swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1x));
+        .forEach((swarmName) => swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1y));
     swarm$1.agentValidationService.getAgentList().forEach((agentName) => {
         const { dependsOn } = swarm$1.agentSchemaService.get(agentName);
         if (!dependsOn) {
@@ -18694,11 +18694,11 @@ const dumpDocs = beginContext((prefix = "swarm", dirName = "./docs/chat", PlantU
     });
     swarm$1.outlineValidationService
         .getOutlineList()
-        .forEach((swarmName) => swarm$1.outlineValidationService.validate(swarmName, METHOD_NAME$1x));
+        .forEach((swarmName) => swarm$1.outlineValidationService.validate(swarmName, METHOD_NAME$1y));
     return swarm$1.docService.dumpDocs(prefix, dirName, sanitizeMarkdown);
 });
 
-const METHOD_NAME$1w = "cli.dumpAgent";
+const METHOD_NAME$1x = "cli.dumpAgent";
 /**
  * Dumps the agent information into PlantUML format.
  *
@@ -18707,14 +18707,14 @@ const METHOD_NAME$1w = "cli.dumpAgent";
  */
 const dumpAgent = beginContext((agentName, { withSubtree = false } = {}) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$1w, {
+        swarm$1.loggerService.log(METHOD_NAME$1x, {
             agentName,
         });
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1w);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1x);
     return swarm$1.agentMetaService.toUML(agentName, withSubtree);
 });
 
-const METHOD_NAME$1v = "cli.dumpSwarm";
+const METHOD_NAME$1w = "cli.dumpSwarm";
 /**
  * Dumps the swarm information into PlantUML format.
  *
@@ -18723,14 +18723,14 @@ const METHOD_NAME$1v = "cli.dumpSwarm";
  */
 const dumpSwarm = beginContext((swarmName) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$1v, {
+        swarm$1.loggerService.log(METHOD_NAME$1w, {
             swarmName,
         });
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1v);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1w);
     return swarm$1.swarmMetaService.toUML(swarmName);
 });
 
-const METHOD_NAME$1u = "cli.dumpPerfomance";
+const METHOD_NAME$1v = "cli.dumpPerfomance";
 const METHOD_NAME_INTERNAL$1 = "cli.dumpPerfomance.internal";
 const METHOD_NAME_INTERVAL = "cli.dumpPerfomance.interval";
 /**
@@ -18749,7 +18749,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$1u);
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$1v);
     await dumpPerfomanceInternal(dirName);
 };
 /**
@@ -18807,7 +18807,7 @@ const listenExecutionEvent = beginContext((clientId, fn) => {
     return swarm$1.busService.subscribe(clientId, "execution-bus", functoolsKit.queued(async (e) => await fn(e)));
 });
 
-const METHOD_NAME$1t = "cli.dumpClientPerformance";
+const METHOD_NAME$1u = "cli.dumpClientPerformance";
 const METHOD_NAME_INTERNAL = "cli.dumpClientPerformance.internal";
 const METHOD_NAME_EXECUTE = "cli.dumpClientPerformance.execute";
 /**
@@ -18831,7 +18831,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$1t);
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$1u);
     await dumpClientPerformanceInternal(clientId, dirName);
 };
 /**
@@ -18852,24 +18852,24 @@ dumpClientPerformance.runAfterExecute = beginContext(async (dirName = "./logs/cl
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$1s = "function.commit.commitFlushForce";
+const METHOD_NAME$1t = "function.commit.commitFlushForce";
 /**
  * Function implementation
  */
 const commitFlushForceInternal = beginContext(async (clientId) => {
     // Log the flush attempt if enabled
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$1s, {
+        swarm$1.loggerService.log(METHOD_NAME$1t, {
             clientId,
-            METHOD_NAME: METHOD_NAME$1s,
+            METHOD_NAME: METHOD_NAME$1t,
         });
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1s);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1t);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1s);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1t);
     // Commit the flush of agent history via SessionPublicService without agent checks
-    await swarm$1.sessionPublicService.commitFlush(METHOD_NAME$1s, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitFlush(METHOD_NAME$1t, clientId, swarmName);
 });
 /**
  * Forcefully commits a flush of agent history for a specific client in the swarm system, without checking the active agent.
@@ -18889,24 +18889,24 @@ async function commitFlushForce(clientId) {
     return await commitFlushForceInternal(clientId);
 }
 
-const METHOD_NAME$1r = "function.commit.commitToolOutputForce";
+const METHOD_NAME$1s = "function.commit.commitToolOutputForce";
 /**
  * Function implementation
  */
 const commitToolOutputForceInternal = 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$1r, {
+        swarm$1.loggerService.log(METHOD_NAME$1s, {
             toolId,
             content,
             clientId,
         });
     // Validate the session and swarm to ensure they exist and are accessible
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1r);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1s);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1r);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1s);
     // 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$1r, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitToolOutput(toolId, content, METHOD_NAME$1s, clientId, swarmName);
 });
 /**
  * Commits the output of a tool execution to the active agent in a swarm session without checking the active agent.
@@ -18931,15 +18931,15 @@ async function commitToolOutputForce(toolId, content, clientId) {
  * @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$1q = "function.common.hasNavigation";
+const METHOD_NAME$1r = "function.common.hasNavigation";
 /**
  * Function implementation
  */
 const hasNavigationInternal = async (clientId, agentName) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$1q, { clientId });
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1q);
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1q);
+        swarm$1.loggerService.log(METHOD_NAME$1r, { clientId });
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1r);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1r);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     return swarm$1.navigationValidationService
         .getNavigationRoute(clientId, swarmName)
@@ -18957,14 +18957,14 @@ async function hasNavigation(clientId, agentName) {
     return await hasNavigationInternal(clientId, agentName);
 }
 
-const METHOD_NAME$1p = "function.history.getRawHistory";
+const METHOD_NAME$1q = "function.history.getRawHistory";
 /**
  * Function implementation
  */
 const getRawHistoryInternal = beginContext(async (clientId, methodName) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$1p, {
+        swarm$1.loggerService.log(METHOD_NAME$1q, {
             clientId,
         });
     // Validate the session and swarm
@@ -18993,21 +18993,21 @@ const getRawHistoryInternal = beginContext(async (clientId, methodName) => {
  * console.log(rawHistory); // Outputs the full raw history array
  */
 async function getRawHistory(clientId) {
-    return await getRawHistoryInternal(clientId, METHOD_NAME$1p);
+    return await getRawHistoryInternal(clientId, METHOD_NAME$1q);
 }
 
-const METHOD_NAME$1o = "function.history.getLastUserMessage";
+const METHOD_NAME$1p = "function.history.getLastUserMessage";
 /**
  * Function implementation
  */
 const getLastUserMessageInternal = 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$1o, {
+        swarm$1.loggerService.log(METHOD_NAME$1p, {
             clientId,
         });
     // Fetch raw history and find the last user message
-    const history = await getRawHistoryInternal(clientId, METHOD_NAME$1o);
+    const history = await getRawHistoryInternal(clientId, METHOD_NAME$1p);
     const last = history.findLast(({ role, mode }) => role === "user" && mode === "user");
     return last?.content ? last.content : null;
 });
@@ -19031,7 +19031,7 @@ async function getLastUserMessage(clientId) {
 
 const disposeSubject = new functoolsKit.Subject();
 
-const METHOD_NAME$1n = "function.navigate.changeToDefaultAgent";
+const METHOD_NAME$1o = "function.navigate.changeToDefaultAgent";
 /**
  * Creates a change agent function with time-to-live (TTL) and queuing capabilities for switching to the default agent.
  *
@@ -19054,7 +19054,7 @@ const createChangeToDefaultAgent = functoolsKit.memoize(([clientId]) => `${clien
     }));
     {
         // Dispose of the current agent's resources and set up the new default agent
-        const agentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1n, clientId, swarmName);
+        const agentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1o, 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));
@@ -19082,20 +19082,20 @@ const createGc$3 = functoolsKit.singleshot(async () => {
 const changeToDefaultAgentInternal = 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$1n, {
+        swarm$1.loggerService.log(METHOD_NAME$1o, {
             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$1n);
-        swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1n);
+        swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1o);
+        swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1o);
     }
     // Execute the agent change with TTL and queuing
     const run = await createChangeToDefaultAgent(clientId);
     createGc$3();
-    return await run(METHOD_NAME$1n, agentName, swarmName);
+    return await run(METHOD_NAME$1o, agentName, swarmName);
 });
 /**
  * Navigates back to the default agent for a given client session in a swarm.
@@ -19114,23 +19114,23 @@ async function changeToDefaultAgent(clientId) {
     return await changeToDefaultAgentInternal(clientId);
 }
 
-const METHOD_NAME$1m = "function.target.emitForce";
+const METHOD_NAME$1n = "function.target.emitForce";
 /**
  * Function implementation
  */
 const emitForceInternal = 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$1m, {
+        swarm$1.loggerService.log(METHOD_NAME$1n, {
             content,
             clientId,
         });
     // Validate the session and swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1m);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1n);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1m);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1n);
     // Emit the content directly via the session public service
-    return await swarm$1.sessionPublicService.emit(content, METHOD_NAME$1m, clientId, swarmName);
+    return await swarm$1.sessionPublicService.emit(content, METHOD_NAME$1n, clientId, swarmName);
 });
 /**
  * Emits a string as model output without executing an incoming message or checking the active agent.
@@ -19151,7 +19151,7 @@ async function emitForce(content, clientId) {
     return await emitForceInternal(content, clientId);
 }
 
-const METHOD_NAME$1l = "function.target.executeForce";
+const METHOD_NAME$1m = "function.target.executeForce";
 /**
  * Function implementation
  */
@@ -19159,22 +19159,22 @@ const executeForceInternal = 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$1l, {
+        swarm$1.loggerService.log(METHOD_NAME$1m, {
             content,
             clientId,
             executionId,
         });
     // Validate the session and swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1l);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1m);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1l);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1m);
     // 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$1l, clientId, swarmName);
+            const result = await swarm$1.sessionPublicService.execute(content, "tool", METHOD_NAME$1m, clientId, swarmName);
             isFinished = swarm$1.perfService.endExecution(executionId, clientId, result.length);
             swarm$1.busService.commitExecutionEnd(clientId, { swarmName });
             return result;
@@ -19212,24 +19212,24 @@ async function executeForce(content, clientId) {
 }
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$1k = "function.commit.commitStopToolsForce";
+const METHOD_NAME$1l = "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$1k, {
+        swarm$1.loggerService.log(METHOD_NAME$1l, {
             clientId,
-            METHOD_NAME: METHOD_NAME$1k,
+            METHOD_NAME: METHOD_NAME$1l,
         });
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1k);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1l);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1k);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1l);
     // Commit the stop of the next tool execution via SessionPublicService without agent checks
-    await swarm$1.sessionPublicService.commitStopTools(METHOD_NAME$1k, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitStopTools(METHOD_NAME$1l, clientId, swarmName);
 });
 /**
  * Forcefully prevents the next tool from being executed for a specific client in the swarm system, without checking the active agent.
@@ -19249,7 +19249,7 @@ async function commitStopToolsForce(clientId) {
     return await commitStopToolsForceInternal(clientId);
 }
 
-const METHOD_NAME$1j = "function.template.navigateToTriageAgent";
+const METHOD_NAME$1k = "function.template.navigateToTriageAgent";
 /**
  * Will send tool output directly to the model without any additions
  */
@@ -19300,7 +19300,7 @@ const createNavigateToTriageAgent = ({ flushMessage, beforeNavigate, lastMessage
      */
     return beginContext(async (toolId, clientId) => {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-            swarm$1.loggerService.log(METHOD_NAME$1j, {
+            swarm$1.loggerService.log(METHOD_NAME$1k, {
                 clientId,
                 toolId,
             });
@@ -19335,7 +19335,7 @@ const createNavigateToTriageAgent = ({ flushMessage, beforeNavigate, lastMessage
     });
 };
 
-const METHOD_NAME$1i = "function.navigate.changeToAgent";
+const METHOD_NAME$1j = "function.navigate.changeToAgent";
 /**
  * Creates a change agent function with time-to-live (TTL) and queuing capabilities.
  *
@@ -19359,7 +19359,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$1i, clientId, swarmName);
+        const agentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1j, 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));
@@ -19387,16 +19387,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$1i, {
+        swarm$1.loggerService.log(METHOD_NAME$1j, {
             agentName,
             clientId,
         });
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     {
         // Validate session, agent, and dependencies
-        swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1i);
-        swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1i);
-        const activeAgent = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1i, clientId, swarmName);
+        swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1j);
+        swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1j);
+        const activeAgent = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1j, clientId, swarmName);
         if (!swarm$1.agentValidationService.hasDependency(activeAgent, agentName)) {
             console.error(`agent-swarm missing dependency detected for activeAgent=${activeAgent} dependencyAgent=${agentName}`);
         }
@@ -19414,7 +19414,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$1i, agentName, swarmName);
+    return await run(METHOD_NAME$1j, agentName, swarmName);
 });
 /**
  * Changes the active agent for a given client session in a swarm.
@@ -19434,7 +19434,7 @@ async function changeToAgent(agentName, clientId) {
     return await changeToAgentInternal(agentName, clientId);
 }
 
-const METHOD_NAME$1h = "function.template.navigateToAgent";
+const METHOD_NAME$1i = "function.template.navigateToAgent";
 /**
  * Will send tool output directly to the model without any additions
  */
@@ -19510,7 +19510,7 @@ const createNavigateToAgent = ({ beforeNavigate, lastMessage: lastMessageFn = DE
      */
     return beginContext(async (toolId, clientId, agentName) => {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-            swarm$1.loggerService.log(METHOD_NAME$1h, {
+            swarm$1.loggerService.log(METHOD_NAME$1i, {
                 clientId,
                 toolId,
             });
@@ -19548,14 +19548,14 @@ const createNavigateToAgent = ({ beforeNavigate, lastMessage: lastMessageFn = DE
     });
 };
 
-const METHOD_NAME$1g = "function.setup.addTool";
+const METHOD_NAME$1h = "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$1g, {
+        swarm$1.loggerService.log(METHOD_NAME$1h, {
             toolSchema,
         });
     // Register the tool in the validation and schema services
@@ -19590,12 +19590,12 @@ 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$1f = "function.alias.addAgentNavigation";
+const METHOD_NAME$1g = "function.alias.addAgentNavigation";
 /**
  * Function implementation
  */
 const addAgentNavigationInternal = beginContext(({ toolName, docNote, description, navigateTo, ...navigateProps }) => {
-    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$1f);
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$1g);
     const navigate = createNavigateToAgent(navigateProps);
     const toolSchema = addTool({
         toolName,
@@ -19639,12 +19639,12 @@ 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$1e = "function.alias.addTriageNavigation";
+const METHOD_NAME$1f = "function.alias.addTriageNavigation";
 /**
  * Function implementation
  */
 const addTriageNavigationInternal = beginContext(({ toolName, docNote, description, ...navigateProps }) => {
-    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$1e);
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$1f);
     const navigate = createNavigateToTriageAgent(navigateProps);
     const toolSchema = addTool({
         toolName,
@@ -19684,13 +19684,13 @@ function addTriageNavigation(params) {
 }
 
 /** @constant {string} METHOD_NAME - The name of the method used for logging */
-const METHOD_NAME$1d = "function.setup.addWiki";
+const METHOD_NAME$1e = "function.setup.addWiki";
 /**
  * Function implementation
  */
 const addWikiInternal = beginContext((wikiSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$1d, {
+        swarm$1.loggerService.log(METHOD_NAME$1e, {
             wikiSchema,
         });
     swarm$1.wikiValidationService.addWiki(wikiSchema.wikiName, wikiSchema);
@@ -19777,14 +19777,14 @@ const mapAgentSchema = ({ system, systemDynamic, systemStatic, ...schema }) => r
         : systemDynamic,
 });
 
-const METHOD_NAME$1c = "function.setup.addAgent";
+const METHOD_NAME$1d = "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$1c, {
+        swarm$1.loggerService.log(METHOD_NAME$1d, {
             agentSchema: publicAgentSchema,
         });
     const agentSchema = mapAgentSchema(publicAgentSchema);
@@ -19814,14 +19814,14 @@ function addAgent(agentSchema) {
     return addAgentInternal(agentSchema);
 }
 
-const METHOD_NAME$1b = "function.setup.addCompletion";
+const METHOD_NAME$1c = "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$1b, {
+        swarm$1.loggerService.log(METHOD_NAME$1c, {
             completionSchema,
         });
     // Register the completion in the validation and schema services
@@ -19850,14 +19850,14 @@ function addCompletion(completionSchema) {
     return addCompletionInternal(completionSchema);
 }
 
-const METHOD_NAME$1a = "function.setup.addSwarm";
+const METHOD_NAME$1b = "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$1a, {
+        swarm$1.loggerService.log(METHOD_NAME$1b, {
             swarmSchema,
         });
     // Register the swarm in the validation and schema services
@@ -19886,13 +19886,13 @@ function addSwarm(swarmSchema) {
     return addSwarmInternal(swarmSchema);
 }
 
-const METHOD_NAME$19 = "function.setup.addMCP";
+const METHOD_NAME$1a = "function.setup.addMCP";
 /**
  * Function implementation
  */
 const addMCPInternal = beginContext((mcpSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$19, {
+        swarm$1.loggerService.log(METHOD_NAME$1a, {
             mcpSchema,
         });
     swarm$1.mcpValidationService.addMCP(mcpSchema.mcpName, mcpSchema);
@@ -19908,14 +19908,14 @@ function addMCP(mcpSchema) {
     return addMCPInternal(mcpSchema);
 }
 
-const METHOD_NAME$18 = "function.setup.addState";
+const METHOD_NAME$19 = "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$18, {
+        swarm$1.loggerService.log(METHOD_NAME$19, {
             stateSchema,
         });
     // Register the policy with StateValidationService for runtime validation
@@ -19953,14 +19953,14 @@ function addState(stateSchema) {
     return addStateInternal(stateSchema);
 }
 
-const METHOD_NAME$17 = "function.setup.addEmbedding";
+const METHOD_NAME$18 = "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$17, {
+        swarm$1.loggerService.log(METHOD_NAME$18, {
             embeddingSchema,
         });
     // Register the embedding in the validation and schema services
@@ -19989,14 +19989,14 @@ function addEmbedding(embeddingSchema) {
     return addEmbeddingInternal(embeddingSchema);
 }
 
-const METHOD_NAME$16 = "function.setup.addStorage";
+const METHOD_NAME$17 = "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$16, {
+        swarm$1.loggerService.log(METHOD_NAME$17, {
             storageSchema,
         });
     // Register the storage in the validation and schema services
@@ -20034,14 +20034,14 @@ function addStorage(storageSchema) {
 }
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$15 = "function.setup.addPolicy";
+const METHOD_NAME$16 = "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$15, {
+        swarm$1.loggerService.log(METHOD_NAME$16, {
             policySchema,
         });
     // Register the policy with PolicyValidationService for runtime validation
@@ -20102,13 +20102,13 @@ function addCompute(computeSchema) {
  * @description Method name for the addPipeline operation.
  * @private
  */
-const METHOD_NAME$14 = "function.setup.addPipeline";
+const METHOD_NAME$15 = "function.setup.addPipeline";
 /**
  * Function implementation
  */
 const addPipelineInternal = beginContext((pipelineSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$14, {
+        swarm$1.loggerService.log(METHOD_NAME$15, {
             pipelineSchema,
         });
     swarm$1.pipelineValidationService.addPipeline(pipelineSchema.pipelineName, pipelineSchema);
@@ -20131,7 +20131,7 @@ function addPipeline(pipelineSchema) {
  * @private
  * @constant {string}
  */
-const METHOD_NAME$13 = "function.setup.addOutline";
+const METHOD_NAME$14 = "function.setup.addOutline";
 /**
  * Internal implementation of the outline addition logic, wrapped in a clean context.
  * Registers the outline schema with both the validation and schema services and logs the operation if enabled.
@@ -20141,7 +20141,7 @@ const METHOD_NAME$13 = "function.setup.addOutline";
  */
 const addOutlineInternal = beginContext((outlineSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$13, {
+        swarm$1.loggerService.log(METHOD_NAME$14, {
             outlineSchema,
         });
     swarm$1.outlineValidationService.addOutline(outlineSchema.outlineName, outlineSchema);
@@ -20159,13 +20159,13 @@ function addOutline(outlineSchema) {
     return addOutlineInternal(outlineSchema);
 }
 
-const METHOD_NAME$12 = "function.test.overrideAgent";
+const METHOD_NAME$13 = "function.test.overrideAgent";
 /**
  * Function implementation
  */
 const overrideAgentInternal = beginContext((publicAgentSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$12, {
+        swarm$1.loggerService.log(METHOD_NAME$13, {
             agentSchema: publicAgentSchema,
         });
     const agentSchema = mapAgentSchema(publicAgentSchema);
@@ -20196,13 +20196,13 @@ function overrideAgent(agentSchema) {
     return overrideAgentInternal(agentSchema);
 }
 
-const METHOD_NAME$11 = "function.test.overrideCompletion";
+const METHOD_NAME$12 = "function.test.overrideCompletion";
 /**
  * Function implementation
  */
 const overrideCompletionInternal = beginContext((completionSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$11, {
+        swarm$1.loggerService.log(METHOD_NAME$12, {
             completionSchema,
         });
     return swarm$1.completionSchemaService.override(completionSchema.completionName, completionSchema);
@@ -20232,13 +20232,13 @@ function overrideCompletion(completionSchema) {
     return overrideCompletionInternal(completionSchema);
 }
 
-const METHOD_NAME$10 = "function.test.overrideEmbeding";
+const METHOD_NAME$11 = "function.test.overrideEmbeding";
 /**
  * Function implementation
  */
 const overrideEmbedingInternal = beginContext((embeddingSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$10, {
+        swarm$1.loggerService.log(METHOD_NAME$11, {
             embeddingSchema,
         });
     return swarm$1.embeddingSchemaService.override(embeddingSchema.embeddingName, embeddingSchema);
@@ -20270,13 +20270,13 @@ function overrideEmbeding(embeddingSchema) {
     return overrideEmbedingInternal(embeddingSchema);
 }
 
-const METHOD_NAME$$ = "function.test.overridePolicy";
+const METHOD_NAME$10 = "function.test.overridePolicy";
 /**
  * Function implementation
  */
 const overridePolicyInternal = beginContext((policySchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$$, {
+        swarm$1.loggerService.log(METHOD_NAME$10, {
             policySchema,
         });
     return swarm$1.policySchemaService.override(policySchema.policyName, policySchema);
@@ -20306,13 +20306,13 @@ function overridePolicy(policySchema) {
     return overridePolicyInternal(policySchema);
 }
 
-const METHOD_NAME$_ = "function.test.overrideState";
+const METHOD_NAME$$ = "function.test.overrideState";
 /**
  * Function implementation
  */
 const overrideStateInternal = beginContext((stateSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$_, {
+        swarm$1.loggerService.log(METHOD_NAME$$, {
             stateSchema,
         });
     return swarm$1.stateSchemaService.override(stateSchema.stateName, stateSchema);
@@ -20343,13 +20343,13 @@ function overrideState(stateSchema) {
     return overrideStateInternal(stateSchema);
 }
 
-const METHOD_NAME$Z = "function.test.overrideStorage";
+const METHOD_NAME$_ = "function.test.overrideStorage";
 /**
  * Function implementation
  */
 const overrideStorageInternal = beginContext((storageSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$Z, {
+        swarm$1.loggerService.log(METHOD_NAME$_, {
             storageSchema,
         });
     return swarm$1.storageSchemaService.override(storageSchema.storageName, storageSchema);
@@ -20381,13 +20381,13 @@ function overrideStorage(storageSchema) {
     return overrideStorageInternal(storageSchema);
 }
 
-const METHOD_NAME$Y = "function.test.overrideSwarm";
+const METHOD_NAME$Z = "function.test.overrideSwarm";
 /**
  * Function implementation
  */
 const overrideSwarmInternal = beginContext((swarmSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$Y, {
+        swarm$1.loggerService.log(METHOD_NAME$Z, {
             swarmSchema,
         });
     return swarm$1.swarmSchemaService.override(swarmSchema.swarmName, swarmSchema);
@@ -20417,13 +20417,13 @@ function overrideSwarm(swarmSchema) {
     return overrideSwarmInternal(swarmSchema);
 }
 
-const METHOD_NAME$X = "function.test.overrideTool";
+const METHOD_NAME$Y = "function.test.overrideTool";
 /**
  * Function implementation
  */
 const overrideToolInternal = beginContext((toolSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$X, {
+        swarm$1.loggerService.log(METHOD_NAME$Y, {
             toolSchema,
         });
     return swarm$1.toolSchemaService.override(toolSchema.toolName, toolSchema);
@@ -20453,13 +20453,13 @@ function overrideTool(toolSchema) {
     return overrideToolInternal(toolSchema);
 }
 
-const METHOD_NAME$W = "function.test.overrideMCP";
+const METHOD_NAME$X = "function.test.overrideMCP";
 /**
  * Function implementation
  */
 const overrideMCPInternal = beginContext((mcpSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$W, {
+        swarm$1.loggerService.log(METHOD_NAME$X, {
             mcpSchema,
         });
     return swarm$1.mcpSchemaService.override(mcpSchema.mcpName, mcpSchema);
@@ -20473,13 +20473,13 @@ function overrideMCP(mcpSchema) {
     return overrideMCPInternal(mcpSchema);
 }
 
-const METHOD_NAME$V = "function.test.overrideWiki";
+const METHOD_NAME$W = "function.test.overrideWiki";
 /**
  * Function implementation
  */
 const overrideWikiInternal = beginContext((wikiSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$V, {
+        swarm$1.loggerService.log(METHOD_NAME$W, {
             wikiSchema,
         });
     return swarm$1.wikiSchemaService.override(wikiSchema.wikiName, wikiSchema);
@@ -20518,13 +20518,13 @@ function overrideWiki(wikiSchema) {
  * @description Method name for the overrideCompute operation.
  * @private
  */
-const METHOD_NAME$U = "function.test.overrideCompute";
+const METHOD_NAME$V = "function.test.overrideCompute";
 /**
  * Function implementation
  */
 const overrideComputeInternal = beginContext((computeSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$U, {
+        swarm$1.loggerService.log(METHOD_NAME$V, {
             computeSchema,
         });
     return swarm$1.computeSchemaService.override(computeSchema.computeName, computeSchema);
@@ -20547,13 +20547,13 @@ function overrideCompute(computeSchema) {
  * @description Method name for the overridePipeline operation.
  * @private
  */
-const METHOD_NAME$T = "function.test.overridePipeline";
+const METHOD_NAME$U = "function.test.overridePipeline";
 /**
  * Function implementation
  */
 const overridePipelineInternal = beginContext((pipelineSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$T, {
+        swarm$1.loggerService.log(METHOD_NAME$U, {
             pipelineSchema,
         });
     return swarm$1.pipelineSchemaService.override(pipelineSchema.pipelineName, pipelineSchema);
@@ -20574,7 +20574,7 @@ function overridePipeline(pipelineSchema) {
  * @private
  * @constant {string}
  */
-const METHOD_NAME$S = "function.test.overrideOutline";
+const METHOD_NAME$T = "function.test.overrideOutline";
 /**
  * Internal implementation of the outline override logic, wrapped in a clean context.
  * Updates the specified outline schema in the swarm's schema service and logs the operation if enabled.
@@ -20583,7 +20583,7 @@ const METHOD_NAME$S = "function.test.overrideOutline";
  */
 const overrideOutlineInternal = beginContext((outlineSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$S, {
+        swarm$1.loggerService.log(METHOD_NAME$T, {
             outlineSchema,
         });
     return swarm$1.outlineSchemaService.override(outlineSchema.outlineName, outlineSchema);
@@ -20598,23 +20598,23 @@ function overrideOutline(outlineSchema) {
     return overrideOutlineInternal(outlineSchema);
 }
 
-const METHOD_NAME$R = "function.other.markOnline";
+const METHOD_NAME$S = "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$R, {
+        swarm.loggerService.log(METHOD_NAME$S, {
             clientId,
         });
     // Validate the swarm name
-    swarm.swarmValidationService.validate(swarmName, METHOD_NAME$R);
+    swarm.swarmValidationService.validate(swarmName, METHOD_NAME$S);
     // Run the operation in the method context
     return await MethodContextService.runInContext(async () => {
-        await swarm.aliveService.markOnline(clientId, swarmName, METHOD_NAME$R);
+        await swarm.aliveService.markOnline(clientId, swarmName, METHOD_NAME$S);
     }, {
-        methodName: METHOD_NAME$R,
+        methodName: METHOD_NAME$S,
         agentName: "",
         policyName: "",
         stateName: "",
@@ -20637,20 +20637,20 @@ async function markOnline(clientId, swarmName) {
     return await markOnlineInternal(clientId, swarmName);
 }
 
-const METHOD_NAME$Q = "function.other.markOffline";
+const METHOD_NAME$R = "function.other.markOffline";
 /**
  * Function implementation
  */
 const markOfflineInternal = async (clientId, swarmName) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm.loggerService.log(METHOD_NAME$Q, {
+        swarm.loggerService.log(METHOD_NAME$R, {
             clientId,
         });
-    swarm.swarmValidationService.validate(swarmName, METHOD_NAME$Q);
+    swarm.swarmValidationService.validate(swarmName, METHOD_NAME$R);
     return await MethodContextService.runInContext(async () => {
-        await swarm.aliveService.markOffline(clientId, swarmName, METHOD_NAME$Q);
+        await swarm.aliveService.markOffline(clientId, swarmName, METHOD_NAME$R);
     }, {
-        methodName: METHOD_NAME$Q,
+        methodName: METHOD_NAME$R,
         agentName: "",
         policyName: "",
         stateName: "",
@@ -20678,27 +20678,27 @@ async function markOffline(clientId, swarmName) {
 }
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$P = "function.commit.commitSystemMessage";
+const METHOD_NAME$Q = "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$P, {
+        swarm$1.loggerService.log(METHOD_NAME$Q, {
             content,
             clientId,
             agentName,
         });
     // Validate the agent exists
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$P);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$Q);
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$P);
+    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$P);
+    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$P, 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 "commitSystemMessage" skipped due to the agent change', {
@@ -20709,7 +20709,7 @@ const commitSystemMessageInternal = beginContext(async (content, clientId, agent
         return;
     }
     // Commit the system message via SessionPublicService
-    await swarm$1.sessionPublicService.commitSystemMessage(content, METHOD_NAME$P, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitSystemMessage(content, METHOD_NAME$Q, clientId, swarmName);
 });
 /**
  * Commits a system-generated message to the active agent in the swarm system.
@@ -20730,26 +20730,26 @@ async function commitSystemMessage(content, clientId, agentName) {
     return await commitSystemMessageInternal(content, clientId, agentName);
 }
 
-const METHOD_NAME$O = "function.commit.commitSystemMessage";
+const METHOD_NAME$P = "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$O, {
+        swarm$1.loggerService.log(METHOD_NAME$P, {
             content,
             clientId,
             agentName,
             mode,
         });
     // Validate the agent, session, and swarm to ensure they exist and are accessible
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$O);
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$O);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$P);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$P);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$O);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$P);
     // Check if the specified agent is still the active agent in the swarm session
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$O, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$P, clientId, swarmName);
     if (currentAgentName !== agentName) {
         // Log a skip message if the agent has changed during the operation
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
@@ -20762,14 +20762,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$O, clientId, swarmName);
+            await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$P, 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$O, clientId, swarmName);
+    return await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$P, clientId, swarmName);
 });
 /**
  * Commits a user message to the active agent's history in a swarm session without triggering a response.
@@ -20791,24 +20791,24 @@ async function commitUserMessage(content, mode, clientId, agentName, payload) {
 }
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$N = "function.commit.commitSystemMessageForce";
+const METHOD_NAME$O = "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$N, {
+        swarm$1.loggerService.log(METHOD_NAME$O, {
             content,
             clientId,
         });
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$N);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$O);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$N);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$O);
     // Commit the system message via SessionPublicService without agent checks
-    await swarm$1.sessionPublicService.commitSystemMessage(content, METHOD_NAME$N, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitSystemMessage(content, METHOD_NAME$O, clientId, swarmName);
 });
 /**
  * Forcefully commits a system-generated message to a session in the swarm system, without checking the active agent.
@@ -20829,32 +20829,32 @@ async function commitSystemMessageForce(content, clientId) {
     return await commitSystemMessageForceInternal(content, clientId);
 }
 
-const METHOD_NAME$M = "function.commit.commitSystemMessage";
+const METHOD_NAME$N = "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$M, {
+        swarm$1.loggerService.log(METHOD_NAME$N, {
             content,
             clientId,
             mode,
         });
     // Validate the session and swarm to ensure they exist and are accessible
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$M);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$N);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$M);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$N);
     if (payload) {
         return await PayloadContextService.runInContext(async () => {
-            await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$M, clientId, swarmName);
+            await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$N, 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$M, clientId, swarmName);
+    return await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$N, 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.
@@ -20875,27 +20875,27 @@ async function commitUserMessageForce(content, mode, clientId, payload) {
 }
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$L = "function.commit.commitAssistantMessage";
+const METHOD_NAME$M = "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$L, {
+        swarm$1.loggerService.log(METHOD_NAME$M, {
             content,
             clientId,
             agentName,
         });
     // Validate the agent exists
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$L);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$M);
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$L);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$M);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$L);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$M);
     // Check if the current agent matches the provided agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$L, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$M, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "commitAssistantMessage" skipped due to the agent change', {
@@ -20906,7 +20906,7 @@ const commitAssistantMessageInternal = beginContext(async (content, clientId, ag
         return;
     }
     // Commit the assistant message via SessionPublicService
-    await swarm$1.sessionPublicService.commitAssistantMessage(content, METHOD_NAME$L, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitAssistantMessage(content, METHOD_NAME$M, clientId, swarmName);
 });
 /**
  * Commits an assistant-generated message to the active agent in the swarm system.
@@ -20927,24 +20927,24 @@ async function commitAssistantMessage(content, clientId, agentName) {
 }
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$K = "function.commit.commitAssistantMessageForce";
+const METHOD_NAME$L = "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$K, {
+        swarm$1.loggerService.log(METHOD_NAME$L, {
             content,
             clientId,
         });
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$K);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$L);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$K);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$L);
     // Commit the assistant message via SessionPublicService without agent checks
-    await swarm$1.sessionPublicService.commitAssistantMessage(content, METHOD_NAME$K, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitAssistantMessage(content, METHOD_NAME$L, clientId, swarmName);
 });
 /**
  * Forcefully commits an assistant-generated message to a session in the swarm system, without checking the active agent.
@@ -20966,26 +20966,26 @@ async function commitAssistantMessageForce(content, clientId) {
 }
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$J = "function.commit.cancelOutput";
+const METHOD_NAME$K = "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$J, {
+        swarm$1.loggerService.log(METHOD_NAME$K, {
             clientId,
             agentName,
         });
     // Validate the agent exists
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$J);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$K);
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$J);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$K);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$J);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$K);
     // Check if the current agent matches the provided agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$J, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$K, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "cancelOutput" skipped due to the agent change', {
@@ -20996,7 +20996,7 @@ const cancelOutputInternal = beginContext(async (clientId, agentName) => {
         return;
     }
     // Perform the output cancellation via SwarmPublicService
-    await swarm$1.swarmPublicService.cancelOutput(METHOD_NAME$J, clientId, swarmName);
+    await swarm$1.swarmPublicService.cancelOutput(METHOD_NAME$K, clientId, swarmName);
 });
 /**
  * Cancels the awaited output for a specific client and agent by emitting an empty string.
@@ -21015,23 +21015,23 @@ async function cancelOutput(clientId, agentName) {
 }
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$I = "function.commit.cancelOutputForce";
+const METHOD_NAME$J = "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$I, {
+        swarm$1.loggerService.log(METHOD_NAME$J, {
             clientId,
         });
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$I);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$J);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$I);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$J);
     // Perform the output cancellation via SwarmPublicService without agent checks
-    await swarm$1.swarmPublicService.cancelOutput(METHOD_NAME$I, clientId, swarmName);
+    await swarm$1.swarmPublicService.cancelOutput(METHOD_NAME$J, clientId, swarmName);
 });
 /**
  * Forcefully cancels the awaited output for a specific client by emitting an empty string, without checking the active agent.
@@ -21050,22 +21050,22 @@ async function cancelOutputForce(clientId) {
     return await cancelOutputForceInternal(clientId);
 }
 
-const METHOD_NAME$H = "function.commit.commitToolRequest";
+const METHOD_NAME$I = "function.commit.commitToolRequest";
 /**
  * Function implementation
  */
 const commitToolRequestInternal = beginContext(async (request, clientId, agentName) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$H, {
+        swarm$1.loggerService.log(METHOD_NAME$I, {
             request,
             clientId,
             agentName,
         });
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$H);
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$H);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$I);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$I);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$H);
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$H, clientId, swarmName);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$I);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$I, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "commitToolRequest" skipped due to the agent change', {
@@ -21075,7 +21075,7 @@ const commitToolRequestInternal = beginContext(async (request, clientId, agentNa
             });
         return null;
     }
-    return await swarm$1.sessionPublicService.commitToolRequest(Array.isArray(request) ? request : [request], METHOD_NAME$H, clientId, swarmName);
+    return await swarm$1.sessionPublicService.commitToolRequest(Array.isArray(request) ? request : [request], METHOD_NAME$I, clientId, swarmName);
 });
 /**
  * Commits a tool request to the active agent in the swarm system.
@@ -21091,21 +21091,21 @@ async function commitToolRequest(request, clientId, agentName) {
     return await commitToolRequestInternal(request, clientId, agentName);
 }
 
-const METHOD_NAME$G = "function.commit.commitToolRequestForce";
+const METHOD_NAME$H = "function.commit.commitToolRequestForce";
 /**
  * Function implementation
  */
 const commitToolRequestForceInternal = beginContext(async (request, clientId) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$G, {
+        swarm$1.loggerService.log(METHOD_NAME$H, {
             request,
             clientId,
         });
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$G);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$H);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$G);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$H);
     const requests = Array.isArray(request) ? request : [request];
-    return await swarm$1.sessionPublicService.commitToolRequest(requests, METHOD_NAME$G, clientId, swarmName);
+    return await swarm$1.sessionPublicService.commitToolRequest(requests, METHOD_NAME$H, clientId, swarmName);
 });
 /**
  * Forcefully commits a tool request to the active agent in the swarm system.
@@ -21122,27 +21122,27 @@ async function commitToolRequestForce(request, clientId) {
 }
 
 /** @constant {string} METHOD_NAME - The name of the method used for logging and validation */
-const METHOD_NAME$F = "function.target.question";
+const METHOD_NAME$G = "function.target.question";
 /**
  * Function implementation
  */
 const questionInternal = beginContext(async (message, clientId, agentName, wikiName) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$F, {
+        swarm$1.loggerService.log(METHOD_NAME$G, {
             message,
             clientId,
             agentName,
             wikiName,
         });
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$F);
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$F);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$G);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$G);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$F);
-    swarm$1.wikiValidationService.validate(wikiName, METHOD_NAME$F);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$G);
+    swarm$1.wikiValidationService.validate(wikiName, METHOD_NAME$G);
     if (!swarm$1.agentValidationService.hasWiki(agentName, wikiName)) {
-        throw new Error(`agent-swarm ${METHOD_NAME$F} ${wikiName} not registered in ${agentName}`);
+        throw new Error(`agent-swarm ${METHOD_NAME$G} ${wikiName} not registered in ${agentName}`);
     }
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$F, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$G, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "question" skipped due to the agent change', {
@@ -21177,23 +21177,23 @@ async function question(message, clientId, agentName, wikiName) {
 }
 
 /** @constant {string} METHOD_NAME - The name of the method used for logging and validation */
-const METHOD_NAME$E = "function.target.questionForce";
+const METHOD_NAME$F = "function.target.questionForce";
 /**
  * Function implementation
  */
 const questionForceInternal = beginContext(async (message, clientId, wikiName) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$E, {
+        swarm$1.loggerService.log(METHOD_NAME$F, {
             message,
             clientId,
             wikiName,
         });
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$E);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$F);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$E);
-    swarm$1.wikiValidationService.validate(wikiName, METHOD_NAME$E);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$F);
+    swarm$1.wikiValidationService.validate(wikiName, METHOD_NAME$F);
     const { getChat, callbacks } = swarm$1.wikiSchemaService.get(wikiName);
-    const agentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$E, clientId, swarmName);
+    const agentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$F, clientId, swarmName);
     const args = {
         clientId,
         message,
@@ -21216,7 +21216,7 @@ async function questionForce(message, clientId, wikiName) {
     return await questionForceInternal(message, clientId, wikiName);
 }
 
-const METHOD_NAME$D = "function.target.json";
+const METHOD_NAME$E = "function.target.json";
 const MAX_ATTEMPTS = 5;
 /**
  * A class implementing the IOutlineHistory interface to manage a history of outline messages.
@@ -21267,11 +21267,11 @@ class OutlineHistory {
  */
 const jsonInternal = beginContext(async (outlineName, param) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$D, {});
-    swarm$1.outlineValidationService.validate(outlineName, METHOD_NAME$D);
+        swarm$1.loggerService.log(METHOD_NAME$E, {});
+    swarm$1.outlineValidationService.validate(outlineName, METHOD_NAME$E);
     const resultId = functoolsKit.randomString();
     const { getOutlineHistory, completion, validations = [], maxAttempts = MAX_ATTEMPTS, format, prompt, system, callbacks: outlineCallbacks, } = swarm$1.outlineSchemaService.get(outlineName);
-    swarm$1.completionValidationService.validate(completion, METHOD_NAME$D);
+    swarm$1.completionValidationService.validate(completion, METHOD_NAME$E);
     const { getCompletion, flags = [], callbacks: completionCallbacks, } = swarm$1.completionSchemaService.get(completion);
     let errorMessage = "";
     let history;
@@ -21387,7 +21387,7 @@ async function json(outlineName, param = {}) {
     return await jsonInternal(outlineName, param);
 }
 
-const METHOD_NAME$C = "function.target.disposeConnection";
+const METHOD_NAME$D = "function.target.disposeConnection";
 /**
  * Disposes of a client session and all related resources within a swarm.
  *
@@ -21404,10 +21404,10 @@ const METHOD_NAME$C = "function.target.disposeConnection";
  * @example
  * await disposeConnection("client-123", "TaskSwarm");
  */
-const disposeConnection = beginContext(async (clientId, swarmName, methodName = METHOD_NAME$C) => {
+const disposeConnection = beginContext(async (clientId, swarmName, methodName = METHOD_NAME$D) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$C, {
+        swarm$1.loggerService.log(METHOD_NAME$D, {
             clientId,
             swarmName,
         });
@@ -21513,7 +21513,7 @@ const disposeConnection = beginContext(async (clientId, swarmName, methodName =
     PersistMemoryAdapter.dispose(clientId);
 });
 
-const METHOD_NAME$B = "function.target.makeAutoDispose";
+const METHOD_NAME$C = "function.target.makeAutoDispose";
 /**
  * Default timeout in seconds before auto-dispose is triggered.
  * @constant {number}
@@ -21544,7 +21544,7 @@ const DEFAULT_TIMEOUT = 15 * 60;
 const makeAutoDispose = beginContext((clientId, swarmName, { timeoutSeconds = DEFAULT_TIMEOUT, onDestroy, } = {}) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$B, {
+        swarm$1.loggerService.log(METHOD_NAME$C, {
             clientId,
             swarmName,
         });
@@ -21577,30 +21577,30 @@ const makeAutoDispose = beginContext((clientId, swarmName, { timeoutSeconds = DE
     };
 });
 
-const METHOD_NAME$A = "function.target.notify";
+const METHOD_NAME$B = "function.target.notify";
 /**
  * Function implementation
  */
 const notifyInternal = beginContext(async (content, clientId, agentName) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$A, {
+        swarm$1.loggerService.log(METHOD_NAME$B, {
             content,
             clientId,
             agentName,
         });
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$A);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$B);
     // Check if the session mode is "makeConnection"
     if (swarm$1.sessionValidationService.getSessionMode(clientId) !==
         "makeConnection") {
         throw new Error(`agent-swarm-kit notify session is not makeConnection clientId=${clientId}`);
     }
     // Validate the agent, session, and swarm
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$A);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$B);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$A);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$B);
     // Check if the specified agent is still the active agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$A, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$B, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "notify" skipped due to the agent change', {
@@ -21611,7 +21611,7 @@ const notifyInternal = beginContext(async (content, clientId, agentName) => {
         return;
     }
     // Notify the content directly via the session public service
-    return await swarm$1.sessionPublicService.notify(content, METHOD_NAME$A, clientId, swarmName);
+    return await swarm$1.sessionPublicService.notify(content, METHOD_NAME$B, clientId, swarmName);
 });
 /**
  * Sends a notification message as output from the swarm session without executing an incoming message.
@@ -21633,18 +21633,18 @@ async function notify(content, clientId, agentName) {
     return await notifyInternal(content, clientId, agentName);
 }
 
-const METHOD_NAME$z = "function.target.notifyForce";
+const METHOD_NAME$A = "function.target.notifyForce";
 /**
  * Function implementation
  */
 const notifyForceInternal = 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$z, {
+        swarm$1.loggerService.log(METHOD_NAME$A, {
             content,
             clientId,
         });
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$z);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$A);
     // Check if the session mode is "makeConnection"
     if (swarm$1.sessionValidationService.getSessionMode(clientId) !==
         "makeConnection") {
@@ -21652,9 +21652,9 @@ const notifyForceInternal = beginContext(async (content, clientId) => {
     }
     // Validate the agent, session, and swarm
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$z);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$A);
     // Notify the content directly via the session public service
-    return await swarm$1.sessionPublicService.notify(content, METHOD_NAME$z, clientId, swarmName);
+    return await swarm$1.sessionPublicService.notify(content, METHOD_NAME$A, clientId, swarmName);
 });
 /**
  * Sends a notification message as output from the swarm session without executing an incoming message.
@@ -21675,7 +21675,7 @@ async function notifyForce(content, clientId) {
     return await notifyForceInternal(content, clientId);
 }
 
-const METHOD_NAME$y = "function.target.runStateless";
+const METHOD_NAME$z = "function.target.runStateless";
 /**
  * Function implementation
  */
@@ -21683,19 +21683,19 @@ const runStatelessInternal = beginContext(async (content, clientId, agentName) =
     const executionId = functoolsKit.randomString();
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$y, {
+        swarm$1.loggerService.log(METHOD_NAME$z, {
             content,
             clientId,
             agentName,
             executionId,
         });
     // Validate the agent, session, and swarm
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$y);
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$y);
+    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$y);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$z);
     // Check if the specified agent is still the active agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$y, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$z, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "runStateless" skipped due to the agent change', {
@@ -21714,7 +21714,7 @@ const runStatelessInternal = beginContext(async (content, clientId, agentName) =
                 agentName,
                 swarmName,
             });
-            const result = await swarm$1.sessionPublicService.run(content, METHOD_NAME$y, clientId, swarmName);
+            const result = await swarm$1.sessionPublicService.run(content, METHOD_NAME$z, clientId, swarmName);
             isFinished = swarm$1.perfService.endExecution(executionId, clientId, result.length);
             swarm$1.busService.commitExecutionEnd(clientId, {
                 agentName,
@@ -21756,7 +21756,7 @@ async function runStateless(content, clientId, agentName) {
     return await runStatelessInternal(content, clientId, agentName);
 }
 
-const METHOD_NAME$x = "function.target.runStatelessForce";
+const METHOD_NAME$y = "function.target.runStatelessForce";
 /**
  * Function implementation
  */
@@ -21764,22 +21764,22 @@ const runStatelessForceInternal = 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$x, {
+        swarm$1.loggerService.log(METHOD_NAME$y, {
             content,
             clientId,
             executionId,
         });
     // Validate the session and swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$x);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$y);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$x);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$y);
     // Execute the command statelessly within an execution context with performance tracking
     return ExecutionContextService.runInContext(async () => {
         let isFinished = false;
         swarm$1.perfService.startExecution(executionId, clientId, content.length);
         try {
             swarm$1.busService.commitExecutionBegin(clientId, { swarmName });
-            const result = await swarm$1.sessionPublicService.run(content, METHOD_NAME$x, clientId, swarmName);
+            const result = await swarm$1.sessionPublicService.run(content, METHOD_NAME$y, clientId, swarmName);
             isFinished = swarm$1.perfService.endExecution(executionId, clientId, result.length);
             swarm$1.busService.commitExecutionEnd(clientId, { swarmName });
             return result;
@@ -21826,7 +21826,7 @@ const SCHEDULED_DELAY$1 = 1000;
  * @constant {number}
  */
 const RATE_DELAY = 10000;
-const METHOD_NAME$w = "function.target.makeConnection";
+const METHOD_NAME$x = "function.target.makeConnection";
 /**
  * Internal implementation of the connection factory for a client to a swarm.
  *
@@ -21841,21 +21841,21 @@ const METHOD_NAME$w = "function.target.makeConnection";
 const makeConnectionInternal = (connector, clientId, swarmName) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$w, {
+        swarm$1.loggerService.log(METHOD_NAME$x, {
             clientId,
             swarmName,
         });
     // Validate the swarm and initialize the session
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$w);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$x);
     swarm$1.sessionValidationService.addSession(clientId, swarmName, "makeConnection");
     // Create a queued send function using the session public service
-    const send = functoolsKit.queued(swarm$1.sessionPublicService.connect(connector, METHOD_NAME$w, clientId, swarmName));
+    const send = functoolsKit.queued(swarm$1.sessionPublicService.connect(connector, METHOD_NAME$x, clientId, swarmName));
     // Return a wrapped send function with validation and agent context
     return (async (outgoing) => {
-        swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$w);
+        swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$x);
         return await send({
             data: outgoing,
-            agentName: await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$w, clientId, swarmName),
+            agentName: await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$x, clientId, swarmName),
             clientId,
         });
     });
@@ -21938,13 +21938,13 @@ makeConnection.scheduled = (connector, clientId, swarmName, { delay = SCHEDULED_
             await online();
             if (payload) {
                 return await PayloadContextService.runInContext(async () => {
-                    await swarm$1.sessionPublicService.commitUserMessage(content, "user", METHOD_NAME$w, clientId, swarmName);
+                    await swarm$1.sessionPublicService.commitUserMessage(content, "user", METHOD_NAME$x, clientId, swarmName);
                 }, {
                     clientId,
                     payload,
                 });
             }
-            await swarm$1.sessionPublicService.commitUserMessage(content, "user", METHOD_NAME$w, clientId, swarmName);
+            await swarm$1.sessionPublicService.commitUserMessage(content, "user", METHOD_NAME$x, clientId, swarmName);
         }),
         delay,
     });
@@ -22007,7 +22007,7 @@ makeConnection.rate = (connector, clientId, swarmName, { delay = RATE_DELAY } =
     };
 };
 
-const METHOD_NAME$v = "function.target.complete";
+const METHOD_NAME$w = "function.target.complete";
 /**
  * Creates a complete function with time-to-live (TTL) and queuing capabilities.
  *
@@ -22060,7 +22060,7 @@ const complete = beginContext(async (content, clientId, swarmName, payload = nul
     const executionId = functoolsKit.randomString();
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$v, {
+        swarm$1.loggerService.log(METHOD_NAME$w, {
             content,
             clientId,
             executionId,
@@ -22078,7 +22078,7 @@ const complete = beginContext(async (content, clientId, swarmName, payload = nul
             swarm$1.navigationValidationService.beginMonit(clientId, swarmName);
             try {
                 swarm$1.busService.commitExecutionBegin(clientId, { swarmName });
-                const result = await run(METHOD_NAME$v, content);
+                const result = await run(METHOD_NAME$w, content);
                 isFinished = swarm$1.perfService.endExecution(executionId, clientId, result.length);
                 swarm$1.busService.commitExecutionEnd(clientId, { swarmName });
                 return result;
@@ -22109,7 +22109,7 @@ const complete = beginContext(async (content, clientId, swarmName, payload = nul
  * @constant {number}
  */
 const SCHEDULED_DELAY = 1000;
-const METHOD_NAME$u = "function.target.session";
+const METHOD_NAME$v = "function.target.session";
 /**
  * Internal implementation of the session factory for a client and swarm.
  *
@@ -22124,23 +22124,23 @@ const sessionInternal = (clientId, swarmName, { onDispose = () => { } } = {}) =>
     const executionId = functoolsKit.randomString();
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$u, {
+        swarm$1.loggerService.log(METHOD_NAME$v, {
             clientId,
             swarmName,
             executionId,
         });
     // Validate the swarm and initialize the session
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$u);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$v);
     swarm$1.sessionValidationService.addSession(clientId, swarmName, "session");
     const complete = functoolsKit.queued(async (content) => {
-        swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$u);
+        swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$v);
         return ExecutionContextService.runInContext(async () => {
             let isFinished = false;
             swarm$1.perfService.startExecution(executionId, clientId, content.length);
             swarm$1.navigationValidationService.beginMonit(clientId, swarmName);
             try {
                 swarm$1.busService.commitExecutionBegin(clientId, { swarmName });
-                const result = await swarm$1.sessionPublicService.execute(content, "user", METHOD_NAME$u, clientId, swarmName);
+                const result = await swarm$1.sessionPublicService.execute(content, "user", METHOD_NAME$v, clientId, swarmName);
                 isFinished = swarm$1.perfService.endExecution(executionId, clientId, result.length);
                 swarm$1.busService.commitExecutionEnd(clientId, { swarmName });
                 return result;
@@ -22162,7 +22162,7 @@ const sessionInternal = (clientId, swarmName, { onDispose = () => { } } = {}) =>
             return await complete(content);
         }),
         dispose: async () => {
-            await disposeConnection(clientId, swarmName, METHOD_NAME$u);
+            await disposeConnection(clientId, swarmName, METHOD_NAME$v);
             await onDispose();
         },
     };
@@ -22262,13 +22262,13 @@ session.scheduled = (clientId, swarmName, { delay = SCHEDULED_DELAY, onDispose }
             await online();
             if (payload) {
                 return await PayloadContextService.runInContext(async () => {
-                    return await swarm$1.sessionPublicService.commitUserMessage(content, "user", METHOD_NAME$u, clientId, swarmName);
+                    return await swarm$1.sessionPublicService.commitUserMessage(content, "user", METHOD_NAME$v, clientId, swarmName);
                 }, {
                     clientId,
                     payload,
                 });
             }
-            return await swarm$1.sessionPublicService.commitUserMessage(content, "user", METHOD_NAME$u, clientId, swarmName);
+            return await swarm$1.sessionPublicService.commitUserMessage(content, "user", METHOD_NAME$v, clientId, swarmName);
         }),
         delay,
     });
@@ -22356,13 +22356,13 @@ session.rate = (clientId, swarmName, { delay = SCHEDULED_DELAY, onDispose } = {}
  * @description Method name for the scope operation.
  * @private
  */
-const METHOD_NAME$t = "function.target.fork";
+const METHOD_NAME$u = "function.target.fork";
 /**
  * Function implementation
  */
 const forkInternal = beginContext(async (runFn, { clientId, swarmName, onError }) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$t, {
+        swarm$1.loggerService.log(METHOD_NAME$u, {
             clientId,
             swarmName,
         });
@@ -22370,9 +22370,9 @@ const forkInternal = beginContext(async (runFn, { clientId, swarmName, onError }
         throw new Error(`agent-swarm scope Session already exists for clientId=${clientId}`);
     }
     swarm$1.sessionValidationService.addSession(clientId, swarmName, "scope");
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$t);
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$t);
-    const agentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$t, clientId, swarmName);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$u);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$u);
+    const agentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$u, clientId, swarmName);
     let result = null;
     try {
         result = (await runFn(clientId, agentName));
@@ -22382,7 +22382,7 @@ const forkInternal = beginContext(async (runFn, { clientId, swarmName, onError }
         onError && onError(error);
     }
     finally {
-        await disposeConnection(clientId, swarmName, METHOD_NAME$t);
+        await disposeConnection(clientId, swarmName, METHOD_NAME$u);
     }
     return result;
 });
@@ -22407,12 +22407,12 @@ async function fork(runFn, options) {
  * @description Method name for the scope operation.
  * @private
  */
-const METHOD_NAME$s = "function.target.scope";
+const METHOD_NAME$t = "function.target.scope";
 /**
  * Function implementation
  */
 const scopeInternal = beginContext(async (runFn, { agentSchemaService = swarm$1.agentSchemaService.registry, completionSchemaService = swarm$1.completionSchemaService.registry, computeSchemaService = swarm$1.computeSchemaService.registry, embeddingSchemaService = swarm$1.embeddingSchemaService.registry, mcpSchemaService = swarm$1.mcpSchemaService.registry, pipelineSchemaService = swarm$1.pipelineSchemaService.registry, policySchemaService = swarm$1.policySchemaService.registry, stateSchemaService = swarm$1.stateSchemaService.registry, storageSchemaService = swarm$1.storageSchemaService.registry, swarmSchemaService = swarm$1.swarmSchemaService.registry, toolSchemaService = swarm$1.toolSchemaService.registry, wikiSchemaService = swarm$1.wikiSchemaService.registry, outlineSchemaService = swarm$1.outlineSchemaService.registry, } = {}) => {
-    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$s);
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$t);
     return await SchemaContextService.runInContext(runFn, {
         registry: {
             agentSchemaService,
@@ -22451,20 +22451,20 @@ async function scope(runFn, options) {
  * @description Method name for the startPipeline operation.
  * @private
  */
-const METHOD_NAME$r = "function.target.startPipeline";
+const METHOD_NAME$s = "function.target.startPipeline";
 /**
  * Function implementation
  */
 const startPipelineInternal = beginContext(async (clientId, pipelineName, agentName, payload = {}) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$r, {
+        swarm$1.loggerService.log(METHOD_NAME$s, {
             clientId,
             pipelineName,
         });
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$r);
-    swarm$1.pipelineValidationService.validate(pipelineName, METHOD_NAME$r);
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$r);
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$r, clientId, await swarm$1.sessionValidationService.getSwarm(clientId));
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$s);
+    swarm$1.pipelineValidationService.validate(pipelineName, METHOD_NAME$s);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$s);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$s, clientId, await swarm$1.sessionValidationService.getSwarm(clientId));
     if (currentAgentName !== agentName) {
         await changeToAgent(agentName, clientId);
     }
@@ -22509,13 +22509,13 @@ async function startPipeline(clientId, pipelineName, agentName, payload) {
 }
 
 /** @private Constant defining the method name for logging purposes */
-const METHOD_NAME$q = "function.common.hasSession";
+const METHOD_NAME$r = "function.common.hasSession";
 /**
  * Function implementation
  */
 const hasSessionInternal = (clientId) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$q, { clientId });
+        swarm$1.loggerService.log(METHOD_NAME$r, { clientId });
     return swarm$1.sessionValidationService.hasSession(clientId);
 };
 /**
@@ -22531,22 +22531,22 @@ function hasSession(clientId) {
     return hasSessionInternal(clientId);
 }
 
-const METHOD_NAME$p = "function.common.getCheckBusy";
+const METHOD_NAME$q = "function.common.getCheckBusy";
 /**
  * Function implementation
  */
 const getCheckBusyInternal = beginContext(async (clientId) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$p, {
+        swarm$1.loggerService.log(METHOD_NAME$q, {
             clientId,
         });
     if (!swarm$1.sessionValidationService.hasSession(clientId)) {
         return false;
     }
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$p);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$q);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$p);
-    return await swarm$1.swarmPublicService.getCheckBusy(METHOD_NAME$p, clientId, swarmName);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$q);
+    return await swarm$1.swarmPublicService.getCheckBusy(METHOD_NAME$q, clientId, swarmName);
 });
 /**
  * Checks if the swarm associated with the given client ID is currently busy.
@@ -22558,27 +22558,27 @@ async function getCheckBusy(clientId) {
     return await getCheckBusyInternal(clientId);
 }
 
-const METHOD_NAME$o = "function.common.getAgentHistory";
+const METHOD_NAME$p = "function.common.getAgentHistory";
 /**
  * Function implementation
  */
 const getAgentHistoryInternal = beginContext(async (clientId, agentName) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$o, {
+        swarm$1.loggerService.log(METHOD_NAME$p, {
             clientId,
             agentName,
         });
     // Validate the session and agent to ensure they exist and are accessible
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$o);
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$o);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$p);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$p);
     // Retrieve the agent's prompt configuration from the agent schema service
     const { prompt: upperPrompt } = swarm$1.agentSchemaService.get(agentName);
     const prompt = typeof upperPrompt === "string"
         ? upperPrompt
         : await upperPrompt(clientId, agentName);
     // Fetch the agent's history using the prompt and rescue tweaks via the history public service
-    const history = await swarm$1.historyPublicService.toArrayForAgent(prompt, METHOD_NAME$o, clientId, agentName);
+    const history = await swarm$1.historyPublicService.toArrayForAgent(prompt, METHOD_NAME$p, clientId, agentName);
     // Return a shallow copy of the history array
     return [...history];
 });
@@ -22601,17 +22601,17 @@ async function getAgentHistory(clientId, agentName) {
     return await getAgentHistoryInternal(clientId, agentName);
 }
 
-const METHOD_NAME$n = "function.common.getSessionMode";
+const METHOD_NAME$o = "function.common.getSessionMode";
 const getSessionModeInternal = 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$n, {
+        swarm$1.loggerService.log(METHOD_NAME$o, {
             clientId,
         });
     // Validate the session and swarm to ensure they exist and are accessible
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$n);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$o);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$n);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$o);
     // Retrieve the session mode from the session validation service
     return swarm$1.sessionValidationService.getSessionMode(clientId);
 });
@@ -22633,14 +22633,14 @@ async function getSessionMode(clientId) {
     return await getSessionModeInternal(clientId);
 }
 
-const METHOD_NAME$m = "function.common.getSessionContext";
+const METHOD_NAME$n = "function.common.getSessionContext";
 /**
  * Function implementation
  */
 const getSessionContextInternal = async () => {
     // Log the operation if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$m);
+        swarm$1.loggerService.log(METHOD_NAME$n);
     // Determine the method context, if active
     const methodContext = MethodContextService.hasContext()
         ? swarm$1.methodContextService.context
@@ -22680,17 +22680,17 @@ async function getSessionContext() {
  * @private Constant defining the method name for logging purposes.
  * Used as an identifier in log messages to track calls to `getNavigationRoute`.
  */
-const METHOD_NAME$l = "function.common.getNavigationRoute";
+const METHOD_NAME$m = "function.common.getNavigationRoute";
 /**
  * Function implementation
  */
 const getNavigationRouteInternal = (clientId, swarmName) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$l, {
+        swarm$1.loggerService.log(METHOD_NAME$m, {
             clientId,
             swarmName,
         });
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$l);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$m);
     return swarm$1.navigationValidationService.getNavigationRoute(clientId, swarmName);
 };
 /**
@@ -22709,7 +22709,7 @@ function getNavigationRoute(clientId, swarmName) {
  * Provides a utility to retrieve the model-facing name of a tool for a given agent and client context.
  * Validates tool and agent existence, logs the operation if enabled, and supports both static and dynamic tool name resolution.
  */
-const METHOD_NAME$k = "function.common.getToolNameForModel";
+const METHOD_NAME$l = "function.common.getToolNameForModel";
 /**
  * Internal implementation for resolving the model-facing tool name.
  * Validates the tool and agent, logs the operation, and invokes the tool schema's function property if dynamic.
@@ -22722,13 +22722,13 @@ const METHOD_NAME$k = "function.common.getToolNameForModel";
  */
 const getToolNameForModelInternal = beginContext(async (toolName, clientId, agentName) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$k, {
+        swarm$1.loggerService.log(METHOD_NAME$l, {
             toolName,
             clientId,
             agentName,
         });
-    swarm$1.toolValidationService.validate(toolName, METHOD_NAME$k);
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$k);
+    swarm$1.toolValidationService.validate(toolName, METHOD_NAME$l);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$l);
     const { function: fn } = swarm$1.toolSchemaService.get(toolName);
     if (typeof fn === "function") {
         const { name } = await fn(clientId, agentName);
@@ -22751,18 +22751,18 @@ async function getToolNameForModel(toolName, clientId, agentName) {
     return await getToolNameForModelInternal(toolName, clientId, agentName);
 }
 
-const METHOD_NAME$j = "function.history.getUserHistory";
+const METHOD_NAME$k = "function.history.getUserHistory";
 /**
  * Function implementation
  */
 const getUserHistoryInternal = 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$j, {
+        swarm$1.loggerService.log(METHOD_NAME$k, {
             clientId,
         });
     // Fetch raw history and filter for user role and mode
-    const history = await getRawHistoryInternal(clientId, METHOD_NAME$j);
+    const history = await getRawHistoryInternal(clientId, METHOD_NAME$k);
     return history.filter(({ role, mode }) => role === "user" && mode === "user");
 });
 /**
@@ -22783,18 +22783,18 @@ async function getUserHistory(clientId) {
     return await getUserHistoryInternal(clientId);
 }
 
-const METHOD_NAME$i = "function.history.getAssistantHistory";
+const METHOD_NAME$j = "function.history.getAssistantHistory";
 /**
  * Function implementation
  */
 const getAssistantHistoryInternal = beginContext(async (clientId) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$i, {
+        swarm$1.loggerService.log(METHOD_NAME$j, {
             clientId,
         });
     // Fetch raw history and filter for assistant role
-    const history = await getRawHistoryInternal(clientId, METHOD_NAME$i);
+    const history = await getRawHistoryInternal(clientId, METHOD_NAME$j);
     return history.filter(({ role }) => role === "assistant");
 });
 /**
@@ -22815,18 +22815,18 @@ async function getAssistantHistory(clientId) {
     return await getAssistantHistoryInternal(clientId);
 }
 
-const METHOD_NAME$h = "function.history.getLastAssistantMessage";
+const METHOD_NAME$i = "function.history.getLastAssistantMessage";
 /**
  * Function implementation
  */
 const getLastAssistantMessageInternal = 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$h, {
+        swarm$1.loggerService.log(METHOD_NAME$i, {
             clientId,
         });
     // Fetch raw history and find the last assistant message
-    const history = await getRawHistoryInternal(clientId, METHOD_NAME$h);
+    const history = await getRawHistoryInternal(clientId, METHOD_NAME$i);
     const last = history.findLast(({ role }) => role === "assistant");
     return last?.content ? last.content : null;
 });
@@ -22848,18 +22848,18 @@ async function getLastAssistantMessage(clientId) {
     return await getLastAssistantMessageInternal(clientId);
 }
 
-const METHOD_NAME$g = "function.history.getLastSystemMessage";
+const METHOD_NAME$h = "function.history.getLastSystemMessage";
 /**
  * Function implementation
  */
 const getLastSystemMessageInternal = 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$g, {
+        swarm$1.loggerService.log(METHOD_NAME$h, {
             clientId,
         });
     // Fetch raw history and find the last system message
-    const history = await getRawHistoryInternal(clientId, METHOD_NAME$g);
+    const history = await getRawHistoryInternal(clientId, METHOD_NAME$h);
     const last = history.findLast(({ role }) => role === "system");
     return last ? last.content : null;
 });
@@ -22881,7 +22881,7 @@ async function getLastSystemMessage(clientId) {
     return await getLastSystemMessageInternal(clientId);
 }
 
-const METHOD_NAME$f = "function.dump.getAgent";
+const METHOD_NAME$g = "function.dump.getAgent";
 /**
  * Retrieves an agent schema by its name from the swarm's agent schema service.
  * Logs the operation if logging is enabled in the global configuration.
@@ -22892,13 +22892,13 @@ const METHOD_NAME$f = "function.dump.getAgent";
  */
 function getAgent(agentName) {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$f, {
+        swarm$1.loggerService.log(METHOD_NAME$g, {
             agentName,
         });
     return swarm$1.agentSchemaService.get(agentName);
 }
 
-const METHOD_NAME$e = "function.dump.getCompletion";
+const METHOD_NAME$f = "function.dump.getCompletion";
 /**
  * Retrieves a completion schema by its name from the swarm's completion schema service.
  * Logs the operation if logging is enabled in the global configuration.
@@ -22909,13 +22909,13 @@ const METHOD_NAME$e = "function.dump.getCompletion";
  */
 function getCompletion(completionName) {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$e, {
+        swarm$1.loggerService.log(METHOD_NAME$f, {
             completionName,
         });
     return swarm$1.completionSchemaService.get(completionName);
 }
 
-const METHOD_NAME$d = "function.dump.getCompute";
+const METHOD_NAME$e = "function.dump.getCompute";
 /**
  * Retrieves a compute schema by its name from the swarm's compute schema service.
  * Logs the operation if logging is enabled in the global configuration.
@@ -22926,13 +22926,13 @@ const METHOD_NAME$d = "function.dump.getCompute";
  */
 function getCompute(computeName) {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$d, {
+        swarm$1.loggerService.log(METHOD_NAME$e, {
             computeName,
         });
     return swarm$1.computeSchemaService.get(computeName);
 }
 
-const METHOD_NAME$c = "function.dump.getEmbeding";
+const METHOD_NAME$d = "function.dump.getEmbeding";
 /**
  * Retrieves an embedding schema by its name from the swarm's embedding schema service.
  * Logs the operation if logging is enabled in the global configuration.
@@ -22943,13 +22943,13 @@ const METHOD_NAME$c = "function.dump.getEmbeding";
  */
 function getEmbeding(embeddingName) {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$c, {
+        swarm$1.loggerService.log(METHOD_NAME$d, {
             embeddingName,
         });
     return swarm$1.embeddingSchemaService.get(embeddingName);
 }
 
-const METHOD_NAME$b = "function.dump.getMCP";
+const METHOD_NAME$c = "function.dump.getMCP";
 /**
  * Retrieves an MCP (Model Context Protocol) schema by its name from the swarm's MCP schema service.
  * Logs the operation if logging is enabled in the global configuration.
@@ -22960,13 +22960,13 @@ const METHOD_NAME$b = "function.dump.getMCP";
  */
 function getMCP(mcpName) {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$b, {
+        swarm$1.loggerService.log(METHOD_NAME$c, {
             mcpName,
         });
     return swarm$1.mcpSchemaService.get(mcpName);
 }
 
-const METHOD_NAME$a = "function.dump.getPipeline";
+const METHOD_NAME$b = "function.dump.getPipeline";
 /**
  * Retrieves a pipeline schema by its name from the swarm's pipeline schema service.
  * Logs the operation if logging is enabled in the global configuration.
@@ -22977,13 +22977,13 @@ const METHOD_NAME$a = "function.dump.getPipeline";
  */
 function getPipeline(pipelineName) {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$a, {
+        swarm$1.loggerService.log(METHOD_NAME$b, {
             pipelineName,
         });
     return swarm$1.pipelineSchemaService.get(pipelineName);
 }
 
-const METHOD_NAME$9 = "function.dump.getPolicy";
+const METHOD_NAME$a = "function.dump.getPolicy";
 /**
  * Retrieves a policy schema by its name from the swarm's policy schema service.
  * Logs the operation if logging is enabled in the global configuration.
@@ -22994,13 +22994,13 @@ const METHOD_NAME$9 = "function.dump.getPolicy";
  */
 function getPolicy(policyName) {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$9, {
+        swarm$1.loggerService.log(METHOD_NAME$a, {
             policyName,
         });
     return swarm$1.policySchemaService.get(policyName);
 }
 
-const METHOD_NAME$8 = "function.dump.getState";
+const METHOD_NAME$9 = "function.dump.getState";
 /**
  * Retrieves a state schema by its name from the swarm's state schema service.
  * Logs the operation if logging is enabled in the global configuration.
@@ -23011,13 +23011,13 @@ const METHOD_NAME$8 = "function.dump.getState";
  */
 function getState(stateName) {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$8, {
+        swarm$1.loggerService.log(METHOD_NAME$9, {
             stateName,
         });
     return swarm$1.stateSchemaService.get(stateName);
 }
 
-const METHOD_NAME$7 = "function.dump.getStorage";
+const METHOD_NAME$8 = "function.dump.getStorage";
 /**
  * Retrieves a storage schema by its name from the swarm's storage schema service.
  * Logs the operation if logging is enabled in the global configuration.
@@ -23028,13 +23028,13 @@ const METHOD_NAME$7 = "function.dump.getStorage";
  */
 function getStorage(storageName) {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$7, {
+        swarm$1.loggerService.log(METHOD_NAME$8, {
             storageName,
         });
     return swarm$1.storageSchemaService.get(storageName);
 }
 
-const METHOD_NAME$6 = "function.dump.getSwarm";
+const METHOD_NAME$7 = "function.dump.getSwarm";
 /**
  * Retrieves a swarm schema by its name from the swarm's swarm schema service.
  * Logs the operation if logging is enabled in the global configuration.
@@ -23045,13 +23045,13 @@ const METHOD_NAME$6 = "function.dump.getSwarm";
  */
 function getSwarm(swarmName) {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$6, {
+        swarm$1.loggerService.log(METHOD_NAME$7, {
             swarmName,
         });
     return swarm$1.swarmSchemaService.get(swarmName);
 }
 
-const METHOD_NAME$5 = "function.dump.getTool";
+const METHOD_NAME$6 = "function.dump.getTool";
 /**
  * Retrieves a tool schema by its name from the swarm's tool schema service.
  * Logs the operation if logging is enabled in the global configuration.
@@ -23062,13 +23062,13 @@ const METHOD_NAME$5 = "function.dump.getTool";
  */
 function getTool(toolName) {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$5, {
+        swarm$1.loggerService.log(METHOD_NAME$6, {
             toolName,
         });
     return swarm$1.toolSchemaService.get(toolName);
 }
 
-const METHOD_NAME$4 = "function.dump.getWiki";
+const METHOD_NAME$5 = "function.dump.getWiki";
 /**
  * Retrieves a wiki schema by its name from the swarm's wiki schema service.
  * Logs the operation if logging is enabled in the global configuration.
@@ -23079,13 +23079,13 @@ const METHOD_NAME$4 = "function.dump.getWiki";
  */
 function getWiki(wikiName) {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$4, {
+        swarm$1.loggerService.log(METHOD_NAME$5, {
             wikiName,
         });
     return swarm$1.wikiSchemaService.get(wikiName);
 }
 
-const METHOD_NAME$3 = "function.event.listenEvent";
+const METHOD_NAME$4 = "function.event.listenEvent";
 /**
  * Set of reserved event source names that cannot be used for custom events.
  * @constant {Set<EventSource>}
@@ -23106,7 +23106,7 @@ const DISALLOWED_EVENT_SOURCE_LIST$2 = new Set([
 const eventInternal = beginContext(async (clientId, topicName, payload) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$3, {
+        swarm$1.loggerService.log(METHOD_NAME$4, {
             clientId,
         });
     // Check if the topic name is reserved
@@ -23142,7 +23142,7 @@ async function event(clientId, topicName, payload) {
     return await eventInternal(clientId, topicName, payload);
 }
 
-const METHOD_NAME$2 = "function.event.listenEvent";
+const METHOD_NAME$3 = "function.event.listenEvent";
 /**
  * Set of reserved event source names that cannot be used for custom event topics.
  * @constant {Set<EventSource>}
@@ -23177,7 +23177,7 @@ const validateClientId$g = (clientId) => {
 const listenEventInternal = beginContext((clientId, topicName, fn) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$2, {
+        swarm$1.loggerService.log(METHOD_NAME$3, {
             clientId,
         });
     // Check if the topic name is reserved
@@ -23213,7 +23213,7 @@ function listenEvent(clientId, topicName, fn) {
     return listenEventInternal(clientId, topicName, fn);
 }
 
-const METHOD_NAME$1 = "function.event.listenEventOnce";
+const METHOD_NAME$2 = "function.event.listenEventOnce";
 /**
  * Set of reserved event source names that cannot be used for custom event topics.
  * @constant {Set<EventSource>}
@@ -23248,7 +23248,7 @@ const validateClientId$f = (clientId) => {
 const listenEventOnceInternal = beginContext((clientId, topicName, filterFn, fn) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$1, {
+        swarm$1.loggerService.log(METHOD_NAME$2, {
             clientId,
         });
     // Check if the topic name is reserved
@@ -23290,7 +23290,7 @@ function listenEventOnce(clientId, topicName, filterFn, fn) {
     return listenEventOnceInternal(clientId, topicName, filterFn, fn);
 }
 
-const METHOD_NAME = "function.navigate.changeToPrevAgent";
+const METHOD_NAME$1 = "function.navigate.changeToPrevAgent";
 /**
  * Creates a change agent function with time-to-live (TTL) and queuing capabilities for switching to the previous agent.
  *
@@ -23313,7 +23313,7 @@ const createChangeToPrevAgent = 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, clientId, swarmName);
+        const agentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1, 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));
@@ -23341,20 +23341,20 @@ const createGc = functoolsKit.singleshot(async () => {
 const changeToPrevAgentInternal = 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, {
+        swarm$1.loggerService.log(METHOD_NAME$1, {
             clientId,
         });
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    const agentName = await swarm$1.swarmPublicService.navigationPop(METHOD_NAME, clientId, swarmName);
+    const agentName = await swarm$1.swarmPublicService.navigationPop(METHOD_NAME$1, clientId, swarmName);
     {
         // Validate session and the retrieved agent
-        swarm$1.sessionValidationService.validate(clientId, METHOD_NAME);
-        swarm$1.agentValidationService.validate(agentName, METHOD_NAME);
+        swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1);
+        swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1);
     }
     // Execute the agent change with TTL and queuing
     const run = await createChangeToPrevAgent(clientId);
     createGc();
-    return await run(METHOD_NAME, agentName, swarmName);
+    return await run(METHOD_NAME$1, agentName, swarmName);
 });
 /**
  * Navigates back to the previous or default agent for a given client session in a swarm.
@@ -25664,6 +25664,34 @@ class AdapterUtils {
  */
 const Adapter = new AdapterUtils();
 
+const METHOD_NAME = "function.common.validate";
+/**
+ * Runs validation for all swarms, agents, and outlines.
+ * This function is wrapped with `singleshot` to ensure it only runs once per process.
+ * Logs the validation process if logging is enabled in the global config.
+ *
+ * @private
+ */
+const validateInternal = functoolsKit.singleshot(() => {
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
+        swarm$1.loggerService.log(METHOD_NAME);
+    const swarmList = swarm$1.swarmValidationService.getSwarmList();
+    const agentList = swarmList.flatMap((swarmName) => swarm$1.swarmValidationService.getAgentList(swarmName));
+    const outlineList = swarm$1.outlineValidationService.getOutlineList();
+    swarmList.forEach((swarmName) => swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME));
+    agentList.forEach((agentName) => swarm$1.agentValidationService.validate(agentName, METHOD_NAME));
+    outlineList.forEach((outlineName) => swarm$1.outlineValidationService.validate(outlineName, METHOD_NAME));
+});
+/**
+ * Validates all swarms, agents, and outlines in the system.
+ * This function is idempotent and will only perform validation once per process.
+ *
+ * @returns {void}
+ */
+function validate() {
+    return validateInternal();
+}
+
 /**
  * Converts a given schema object into a JSON schema format object.
  *
@@ -25851,3 +25879,4 @@ exports.setConfig = setConfig;
 exports.startPipeline = startPipeline;
 exports.swarm = swarm;
 exports.toJsonSchema = toJsonSchema;
+exports.validate = validate;