agent-swarm-kit 1.1.5 → 1.1.7

package/build/index.cjs

@@ -53,6 +53,7 @@ const connectionServices$1 = {
     stateConnectionService: Symbol('stateConnectionService'),
     sharedStateConnectionService: Symbol('sharedStateConnectionService'),
     policyConnectionService: Symbol('policyConnectionService'),
+    mcpConnectionService: Symbol('mcpConnectionService'),
 };
 const schemaServices$1 = {
     completionSchemaService: Symbol('completionSchemaService'),
@@ -65,6 +66,7 @@ const schemaServices$1 = {
     memorySchemaService: Symbol('memorySchemaService'),
     policySchemaService: Symbol('policySchemaService'),
     wikiSchemaService: Symbol('wikiSchemaService'),
+    mcpSchemaService: Symbol('mcpSchemaService'),
 };
 const metaServices$1 = {
     agentMetaService: Symbol('agentMetaService'),
@@ -80,6 +82,7 @@ const publicServices$1 = {
     statePublicService: Symbol('statePublicService'),
     sharedStatePublicService: Symbol('sharedStatePublicService'),
     policyPublicService: Symbol('policyPublicService'),
+    mcpPublicService: Symbol('mcpPublicService'),
 };
 const validationServices$1 = {
     agentValidationService: Symbol('agentValidationService'),
@@ -92,6 +95,7 @@ const validationServices$1 = {
     policyValidationService: Symbol('policyValidationService'),
     navigationValidationService: Symbol('navigationValidationService'),
     wikiValidationService: Symbol('wikiValidationService'),
+    mcpValidationService: Symbol('mcpValidationService'),
 };
 const TYPES = {
     ...baseServices$1,
@@ -2611,6 +2615,7 @@ class LoggerUtils {
                 stateName: "",
                 storageName: "",
                 swarmName: "",
+                mcpName: "",
             });
         });
         /**
@@ -2639,6 +2644,7 @@ class LoggerUtils {
                 stateName: "",
                 storageName: "",
                 swarmName: "",
+                mcpName: "",
             });
         });
         /**
@@ -2667,6 +2673,7 @@ class LoggerUtils {
                 stateName: "",
                 storageName: "",
                 swarmName: "",
+                mcpName: "",
             });
         });
         /**
@@ -3434,6 +3441,16 @@ class AgentSchemaService {
             if (agentSchema.tools?.some((value) => typeof value !== "string")) {
                 throw new Error(`agent-swarm agent schema validation failed: invalid tools for agentName=${agentSchema.agentName} tools=[${agentSchema.tools}]`);
             }
+            if (agentSchema.mcp && !Array.isArray(agentSchema.mcp)) {
+                throw new Error(`agent-swarm agent schema validation failed: invalid mcp for agentName=${agentSchema.agentName} mcp=${agentSchema.mcp}`);
+            }
+            if (agentSchema.mcp &&
+                agentSchema.mcp.length !== new Set(agentSchema.mcp).size) {
+                throw new Error(`agent-swarm agent schema validation failed: found duplicate mcp for agentName=${agentSchema.agentName} mcp=[${agentSchema.mcp}]`);
+            }
+            if (agentSchema.mcp?.some((value) => typeof value !== "string")) {
+                throw new Error(`agent-swarm agent schema validation failed: invalid mcp for agentName=${agentSchema.agentName} mcp=[${agentSchema.mcp}]`);
+            }
         };
         /**
          * Registers a new agent schema in the registry after validation.
@@ -3579,6 +3596,51 @@ const createToolCall = async (idx, tool, toolCalls, targetFn, self) => {
         self._toolErrorSubject.next(TOOL_ERROR_SYMBOL);
     }
 };
+/**
+ * Maps an MCP (Model-Context-Protocol) tool definition to an `IAgentTool` object.
+ * This function transforms the MCP tool's schema and properties into a format compatible with the agent's tool system.
+ * It also defines the tool's behavior, including its call method and parameter validation.
+ *
+ * @param {Object} tool - The MCP tool definition containing its name, description, and input schema.
+ * @param {string} tool.name - The name of the MCP tool.
+ * @param {string} [tool.description=tool.name] - A description of the MCP tool. Defaults to the tool's name if not provided.
+ * @param {Object} [tool.inputSchema] - The input schema for the MCP tool, defining its parameters and validation rules.
+ * @param {Object} [tool.inputSchema.properties] - The properties of the input schema, where each key represents a parameter.
+ * @param {string[]} [tool.inputSchema.required] - An array of required parameter names for the tool.
+ * @param {ClientAgent} self - The `ClientAgent` instance, providing context such as the agent's name, client ID, and logger.
+ *
+ * @returns {IAgentTool} An object representing the mapped tool, including its name, type, function definition, and call behavior.
+ */
+const mapMcpToolCall = ({ name, description = name, inputSchema }, self) => {
+    const mcpProperties = inputSchema
+        ? inputSchema.properties ?? {}
+        : {};
+    return {
+        toolName: `mcp_${name}`,
+        type: "function",
+        function: {
+            name,
+            description,
+            parameters: {
+                type: "object",
+                properties: Object.entries(mcpProperties).reduce((acm, [key, { type, description = type, enum: e }]) => ({
+                    ...acm,
+                    [key]: {
+                        type,
+                        description,
+                        enum: e,
+                    },
+                }), {}),
+                required: inputSchema.required,
+            },
+        },
+        call: async (dto) => {
+            GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
+                self.params.logger.debug(`ClientAgent agentName=${self.params.agentName} clientId=${self.params.clientId} calling MCP tool toolName=${name}`);
+            await self.params.mcp.callTool(name, dto);
+        },
+    };
+};
 /**
  * Runs a stateless completion for the incoming message, returning the transformed result.
  * Returns an empty string if tool calls are present or validation fails, avoiding further processing.
@@ -3604,7 +3666,7 @@ const RUN_FN = async (incoming, self) => {
         agentName: self.params.agentName,
         messages,
         mode: "user",
-        tools: self.params.tools?.map((t) => lodashEs.omit(t, "toolName", "docNote", "call", "validate", "callbacks")),
+        tools: [],
     };
     const rawMessage = await self.params.completion.getCompletion(args);
     self.params.completion.callbacks?.onComplete &&
@@ -3660,7 +3722,8 @@ const EXECUTE_FN = async (incoming, mode, self) => {
         agentName: self.params.agentName,
         content: incoming.trim(),
     });
-    const rawMessage = await self.getCompletion(mode);
+    const toolList = await self._resolveTools();
+    const rawMessage = await self.getCompletion(mode, toolList);
     const message = await self.params.map(rawMessage, self.params.clientId, self.params.agentName);
     if (message.tool_calls?.length) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
@@ -3679,10 +3742,10 @@ const EXECUTE_FN = async (incoming, mode, self) => {
         const [runAwaiter, { resolve: run }] = functoolsKit.createAwaiter();
         for (let idx = 0; idx !== toolCalls.length; idx++) {
             const tool = toolCalls[idx];
-            const targetFn = self.params.tools?.find((t) => t.function.name === tool.function.name);
+            const targetFn = toolList.find((t) => t.function.name === tool.function.name);
             if (!targetFn) {
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
-                    self.params.logger.debug(`ClientAgent agentName=${self.params.agentName} clientId=${self.params.clientId} functionName=${tool.function.name} tool function not found`, self.params.tools);
+                    self.params.logger.debug(`ClientAgent agentName=${self.params.agentName} clientId=${self.params.clientId} functionName=${tool.function.name} tool function not found`, toolList);
                 const result = await self._resurrectModel(mode, `No target function for ${tool.function.name}`);
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
                     self.params.logger.debug(`ClientAgent agentName=${self.params.agentName} clientId=${self.params.clientId} execute end result=${result}`);
@@ -3887,6 +3950,33 @@ class ClientAgent {
             });
         this.params.onInit && this.params.onInit(params.clientId, params.agentName);
     }
+    async _resolveTools() {
+        GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
+            this.params.logger.debug(`ClientAgent agentName=${this.params.agentName} clientId=${this.params.clientId} _resolveTools`);
+        const seen = new Set();
+        const agentToolList = this.params.tools
+            ? this.params.tools
+            : [];
+        const mcpToolList = await this.params.mcp.listTools(this.params.clientId);
+        if (mcpToolList.length) {
+            return agentToolList
+                .concat(mcpToolList.map((tool) => mapMcpToolCall(tool, this)))
+                .filter(({ function: { name } }) => {
+                if (!seen.has(name)) {
+                    seen.add(name);
+                    return true;
+                }
+                return false;
+            });
+        }
+        return agentToolList.filter(({ function: { name } }) => {
+            if (!seen.has(name)) {
+                seen.add(name);
+                return true;
+            }
+            return false;
+        });
+    }
     /**
      * Resolves the system prompt by combining static and dynamic system messages.
      * Static messages are directly included from the `systemStatic` parameter, while dynamic messages
@@ -4013,7 +4103,7 @@ class ClientAgent {
             await this._resqueSubject.next(MODEL_RESQUE_SYMBOL);
             return placeholder;
         }
-        const rawMessage = await this.getCompletion(mode);
+        const rawMessage = await this.getCompletion(mode, []);
         if (rawMessage.tool_calls?.length) {
             GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
                 this.params.logger.debug(`ClientAgent agentName=${this.params.agentName} clientId=${this.params.clientId} _resurrectModel should not emit tool_calls`);
@@ -4066,7 +4156,7 @@ class ClientAgent {
      * @param {ExecutionMode} mode - The execution mode (e.g., "user" or "tool"), determining context.
      * @returns {Promise<IModelMessage>} The completion message from the model, with content defaulted to an empty string if null.
      */
-    async getCompletion(mode) {
+    async getCompletion(mode, tools) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
             this.params.logger.debug(`ClientAgent agentName=${this.params.agentName} clientId=${this.params.clientId} getCompletion`);
         const messages = await this.params.history.toArrayForAgent(this.params.prompt ?? "", await this._resolveSystemPrompt());
@@ -4075,7 +4165,7 @@ class ClientAgent {
             agentName: this.params.agentName,
             messages,
             mode,
-            tools: this.params.tools?.map((t) => lodashEs.omit(t, "toolName", "docNote", "call", "validate", "callbacks")),
+            tools: tools.map((t) => lodashEs.omit(t, "toolName", "docNote", "call", "validate", "callbacks")),
         };
         const output = await this.params.completion.getCompletion(args);
         if (GLOBAL_CONFIG.CC_RESQUE_STRATEGY === "flush") {
@@ -4119,7 +4209,7 @@ class ClientAgent {
                 agentName: this.params.agentName,
                 messages,
                 mode,
-                tools: this.params.tools?.map((t) => lodashEs.omit(t, "toolName", "docNote", "call", "validate", "callbacks")),
+                tools: tools.map((t) => lodashEs.omit(t, "toolName", "docNote", "call", "validate", "callbacks")),
             };
             const output = await this.params.completion.getCompletion(args);
             this.params.completion.callbacks?.onComplete &&
@@ -4557,6 +4647,84 @@ class ClientOperator {
     }
 }
 
+class NoopMCP {
+    constructor(agentName) {
+        this.agentName = agentName;
+        GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
+            swarm$1.loggerService.debug(`NoopMCP CTOR agentName=${agentName}`);
+    }
+    async listTools(clientId) {
+        GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
+            swarm$1.loggerService.debug(`NoopMCP listTools agentName=${this.agentName}`, {
+                clientId,
+            });
+        return [];
+    }
+    hasTool(toolName, clientId) {
+        GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
+            swarm$1.loggerService.debug(`NoopMCP hasTool agentName=${this.agentName}`, {
+                toolName,
+                clientId,
+            });
+        return Promise.resolve(false);
+    }
+    async callTool(toolName, dto) {
+        GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
+            swarm$1.loggerService.debug(`NoopMCP callTool agentName=${this.agentName}`, {
+                toolName,
+                dto,
+            });
+        throw new Error(`NoopPolicy callTool should not be called agentName=${this.agentName} toolName=${toolName}`);
+    }
+}
+class MergeMCP {
+    constructor(mcpList, agentName) {
+        this.mcpList = mcpList;
+        this.agentName = agentName;
+        GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
+            swarm$1.loggerService.debug(`MergeMCP CTOR agentName=${agentName}`, {
+                mcpList,
+            });
+    }
+    async listTools(clientId) {
+        GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
+            swarm$1.loggerService.debug(`MergeMCP listTools agentName=${this.agentName}`, {
+                clientId,
+            });
+        const toolList = [];
+        for (const mcp of this.mcpList) {
+            toolList.push(await mcp.listTools(clientId));
+        }
+        return toolList.flatMap((tools) => tools);
+    }
+    async hasTool(toolName, clientId) {
+        GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
+            swarm$1.loggerService.debug(`MergeMCP hasTool agentName=${this.agentName}`, {
+                toolName,
+                clientId,
+            });
+        for (const mcp of this.mcpList) {
+            if (await mcp.hasTool(toolName, clientId)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    async callTool(toolName, dto) {
+        GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
+            swarm$1.loggerService.debug(`MergeMCP callTool agentName=${this.agentName}`, {
+                toolName,
+                dto,
+            });
+        for (const mcp of this.mcpList) {
+            if (await mcp.hasTool(toolName, dto.clientId)) {
+                return await mcp.callTool(toolName, dto);
+            }
+        }
+        throw new Error(`MergeMCP callTool agentName=${this.agentName} tool not found toolName=${toolName}`);
+    }
+}
+
 /**
  * Service class for managing agent connections and operations in the swarm system.
  * Implements IAgent to provide an interface for agent instantiation, execution, message handling, and lifecycle management.
@@ -4637,6 +4805,13 @@ class AgentConnectionService {
          * @private
          */
         this.completionSchemaService = inject(TYPES.completionSchemaService);
+        /**
+         * MCP connection service instance, injected via DI, for retrieving external tools
+         * Provides mcp integration logic to ClientAgent in getAgent, supporting agent tool execution.
+         * @type {CompletionSchemaService}
+         * @private
+         */
+        this.mcpConnectionService = inject(TYPES.mcpConnectionService);
         /**
          * Retrieves or creates a memoized ClientAgent instance for a given client and agent.
          * Uses functools-kit’s memoize to cache instances by a composite key (clientId-agentName), ensuring efficient reuse across calls.
@@ -4647,7 +4822,7 @@ class AgentConnectionService {
          * @returns {ClientAgent} The memoized ClientAgent instance configured for the client and agent.
          */
         this.getAgent = functoolsKit.memoize(([clientId, agentName]) => `${clientId}-${agentName}`, (clientId, agentName) => {
-            const { prompt, system, operator, systemStatic = system, systemDynamic, tools, transform = GLOBAL_CONFIG.CC_AGENT_OUTPUT_TRANSFORM, map = GLOBAL_CONFIG.CC_AGENT_OUTPUT_MAP, maxToolCalls = GLOBAL_CONFIG.CC_MAX_TOOL_CALLS, mapToolCalls = GLOBAL_CONFIG.CC_AGENT_MAP_TOOLS, callbacks, storages, states, connectOperator = GLOBAL_CONFIG.CC_DEFAULT_CONNECT_OPERATOR, completion: completionName, validate = validateDefault, } = this.agentSchemaService.get(agentName);
+            const { prompt, system, operator, systemStatic = system, systemDynamic, tools, transform = GLOBAL_CONFIG.CC_AGENT_OUTPUT_TRANSFORM, map = GLOBAL_CONFIG.CC_AGENT_OUTPUT_MAP, maxToolCalls = GLOBAL_CONFIG.CC_MAX_TOOL_CALLS, mapToolCalls = GLOBAL_CONFIG.CC_AGENT_MAP_TOOLS, callbacks, storages, states, mcp, connectOperator = GLOBAL_CONFIG.CC_DEFAULT_CONNECT_OPERATOR, completion: completionName, validate = validateDefault, } = this.agentSchemaService.get(agentName);
             const history = this.historyConnectionService.getHistory(clientId, agentName);
             this.sessionValidationService.addAgentUsage(clientId, agentName);
             storages?.forEach((storageName) => this.storageConnectionService
@@ -4675,6 +4850,9 @@ class AgentConnectionService {
                 mapToolCalls,
                 logger: this.loggerService,
                 bus: this.busService,
+                mcp: mcp
+                    ? new MergeMCP(mcp.map(this.mcpConnectionService.getMCP), agentName)
+                    : new NoopMCP(agentName),
                 history,
                 prompt,
                 systemStatic,
@@ -4840,7 +5018,7 @@ class AgentConnectionService {
 }
 
 /** @private Constant defining the method name for logging purposes */
-const METHOD_NAME$1a = "function.common.getPayload";
+const METHOD_NAME$1d = "function.common.getPayload";
 /**
  * Retrieves the payload from the current PayloadContextService context.
  * Returns null if no context is available. Logs the operation if logging is enabled.
@@ -4851,7 +5029,7 @@ const METHOD_NAME$1a = "function.common.getPayload";
  * console.log(payload); // { id: number } or null
  */
 const getPayload = () => {
-    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$1a);
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$1d);
     if (PayloadContextService.hasContext()) {
         const { payload } = swarm$1.payloadContextService.context;
         return payload;
@@ -7129,6 +7307,7 @@ class AgentPublicService {
                 swarmName: "",
                 storageName: "",
                 stateName: "",
+                mcpName: "",
             });
         };
         /**
@@ -7161,6 +7340,7 @@ class AgentPublicService {
                 swarmName: "",
                 storageName: "",
                 stateName: "",
+                mcpName: "",
             });
         };
         /**
@@ -7191,6 +7371,7 @@ class AgentPublicService {
                 swarmName: "",
                 storageName: "",
                 stateName: "",
+                mcpName: "",
             });
         };
         /**
@@ -7219,6 +7400,7 @@ class AgentPublicService {
                 swarmName: "",
                 storageName: "",
                 stateName: "",
+                mcpName: "",
             });
         };
         /**
@@ -7251,6 +7433,7 @@ class AgentPublicService {
                 swarmName: "",
                 storageName: "",
                 stateName: "",
+                mcpName: "",
             });
         };
         /**
@@ -7281,6 +7464,7 @@ class AgentPublicService {
                 swarmName: "",
                 storageName: "",
                 stateName: "",
+                mcpName: "",
             });
         };
         /**
@@ -7311,6 +7495,7 @@ class AgentPublicService {
                 swarmName: "",
                 storageName: "",
                 stateName: "",
+                mcpName: "",
             });
         };
         /**
@@ -7342,6 +7527,7 @@ class AgentPublicService {
                 swarmName: "",
                 storageName: "",
                 stateName: "",
+                mcpName: "",
             });
         };
         /**
@@ -7370,6 +7556,7 @@ class AgentPublicService {
                 swarmName: "",
                 storageName: "",
                 stateName: "",
+                mcpName: "",
             });
         };
         /**
@@ -7398,6 +7585,7 @@ class AgentPublicService {
                 swarmName: "",
                 storageName: "",
                 stateName: "",
+                mcpName: "",
             });
         };
         /**
@@ -7426,6 +7614,7 @@ class AgentPublicService {
                 swarmName: "",
                 storageName: "",
                 stateName: "",
+                mcpName: "",
             });
         };
         /**
@@ -7454,6 +7643,7 @@ class AgentPublicService {
                 swarmName: "",
                 storageName: "",
                 stateName: "",
+                mcpName: "",
             });
         };
     }
@@ -7509,6 +7699,7 @@ class HistoryPublicService {
                 swarmName: "",
                 storageName: "",
                 stateName: "",
+                mcpName: "",
             });
         };
         /**
@@ -7537,6 +7728,7 @@ class HistoryPublicService {
                 swarmName: "",
                 storageName: "",
                 stateName: "",
+                mcpName: "",
             });
         };
         /**
@@ -7566,6 +7758,7 @@ class HistoryPublicService {
                 swarmName: "",
                 storageName: "",
                 stateName: "",
+                mcpName: "",
             });
         };
         /**
@@ -7594,6 +7787,7 @@ class HistoryPublicService {
                 swarmName: "",
                 storageName: "",
                 stateName: "",
+                mcpName: "",
             });
         };
         /**
@@ -7621,6 +7815,7 @@ class HistoryPublicService {
                 swarmName: "",
                 storageName: "",
                 stateName: "",
+                mcpName: "",
             });
         };
     }
@@ -7696,6 +7891,7 @@ class SessionPublicService {
                 agentName: "",
                 storageName: "",
                 stateName: "",
+                mcpName: "",
             });
         };
         /**
@@ -7726,6 +7922,7 @@ class SessionPublicService {
                 agentName: "",
                 storageName: "",
                 stateName: "",
+                mcpName: "",
             });
         };
         /**
@@ -7757,6 +7954,7 @@ class SessionPublicService {
                 agentName: "",
                 storageName: "",
                 stateName: "",
+                mcpName: "",
             });
         };
         /**
@@ -7786,6 +7984,7 @@ class SessionPublicService {
                 agentName: "",
                 storageName: "",
                 stateName: "",
+                mcpName: "",
             });
         };
         /**
@@ -7868,6 +8067,7 @@ class SessionPublicService {
                 agentName: "",
                 storageName: "",
                 stateName: "",
+                mcpName: "",
             });
         };
         /**
@@ -7898,6 +8098,7 @@ class SessionPublicService {
                 agentName: "",
                 storageName: "",
                 stateName: "",
+                mcpName: "",
             });
         };
         /**
@@ -7928,6 +8129,7 @@ class SessionPublicService {
                 agentName: "",
                 storageName: "",
                 stateName: "",
+                mcpName: "",
             });
         };
         /**
@@ -7959,6 +8161,7 @@ class SessionPublicService {
                 agentName: "",
                 storageName: "",
                 stateName: "",
+                mcpName: "",
             });
         };
         /**
@@ -7986,6 +8189,7 @@ class SessionPublicService {
                 agentName: "",
                 storageName: "",
                 stateName: "",
+                mcpName: "",
             });
         };
         /**
@@ -8013,6 +8217,7 @@ class SessionPublicService {
                 agentName: "",
                 storageName: "",
                 stateName: "",
+                mcpName: "",
             });
         };
         /**
@@ -8041,6 +8246,7 @@ class SessionPublicService {
                 agentName: "",
                 storageName: "",
                 stateName: "",
+                mcpName: "",
             });
         };
     }
@@ -8096,6 +8302,7 @@ class SwarmPublicService {
                 agentName: "",
                 storageName: "",
                 stateName: "",
+                mcpName: "",
             });
         };
         /**
@@ -8123,6 +8330,7 @@ class SwarmPublicService {
                 agentName: "",
                 storageName: "",
                 stateName: "",
+                mcpName: "",
             });
         };
         /**
@@ -8150,6 +8358,7 @@ class SwarmPublicService {
                 agentName: "",
                 storageName: "",
                 stateName: "",
+                mcpName: "",
             });
         };
         /**
@@ -8178,6 +8387,7 @@ class SwarmPublicService {
                 agentName: "",
                 storageName: "",
                 stateName: "",
+                mcpName: "",
             });
         };
         /**
@@ -8206,6 +8416,7 @@ class SwarmPublicService {
                 agentName: "",
                 storageName: "",
                 stateName: "",
+                mcpName: "",
             });
         };
         /**
@@ -8233,6 +8444,7 @@ class SwarmPublicService {
                 agentName: "",
                 storageName: "",
                 stateName: "",
+                mcpName: "",
             });
         };
         /**
@@ -8265,6 +8477,7 @@ class SwarmPublicService {
                 agentName: "",
                 storageName: "",
                 stateName: "",
+                mcpName: "",
             });
         };
         /**
@@ -8295,6 +8508,7 @@ class SwarmPublicService {
                 agentName: "",
                 storageName: "",
                 stateName: "",
+                mcpName: "",
             });
         };
         /**
@@ -8323,6 +8537,7 @@ class SwarmPublicService {
                 agentName: "",
                 storageName: "",
                 stateName: "",
+                mcpName: "",
             });
         };
     }
@@ -8362,6 +8577,14 @@ class AgentValidationService {
          * @readonly
          */
         this.wikiValidationService = inject(TYPES.wikiValidationService);
+        /**
+         * MCP validation service instance for validating mcp associated with agents.
+         * Injected via DI, used in validate method to check agent mcp list.
+         * @type {WikiValidationService}
+         * @private
+         * @readonly
+         */
+        this.mcpValidationService = inject(TYPES.mcpValidationService);
         /**
          * Completion validation service instance for validating completion configurations of agents.
          * Injected via DI, used in validate method to check agent completion.
@@ -8589,6 +8812,12 @@ class AgentValidationService {
                 }
                 this.wikiValidationService.validate(wikiName, source);
             });
+            agent.mcp?.forEach((mcpName) => {
+                if (typeof mcpName !== "string") {
+                    throw new Error(`agent-swarm agent ${agentName} mcp list is invalid (mcpName=${String(mcpName)}) source=${source}`);
+                }
+                this.mcpValidationService.validate(mcpName, source);
+            });
         });
     }
 }
@@ -10195,6 +10424,7 @@ class StoragePublicService {
                 agentName: "",
                 swarmName: "",
                 stateName: "",
+                mcpName: "",
             });
         };
         /**
@@ -10224,6 +10454,7 @@ class StoragePublicService {
                 agentName: "",
                 swarmName: "",
                 stateName: "",
+                mcpName: "",
             });
         };
         /**
@@ -10253,6 +10484,7 @@ class StoragePublicService {
                 agentName: "",
                 swarmName: "",
                 stateName: "",
+                mcpName: "",
             });
         };
         /**
@@ -10283,6 +10515,7 @@ class StoragePublicService {
                 agentName: "",
                 swarmName: "",
                 stateName: "",
+                mcpName: "",
             });
         };
         /**
@@ -10312,6 +10545,7 @@ class StoragePublicService {
                 agentName: "",
                 swarmName: "",
                 stateName: "",
+                mcpName: "",
             });
         };
         /**
@@ -10340,6 +10574,7 @@ class StoragePublicService {
                 agentName: "",
                 swarmName: "",
                 stateName: "",
+                mcpName: "",
             });
         };
         /**
@@ -10367,6 +10602,7 @@ class StoragePublicService {
                 agentName: "",
                 swarmName: "",
                 stateName: "",
+                mcpName: "",
             });
         };
     }
@@ -11008,6 +11244,7 @@ class StatePublicService {
                 agentName: "",
                 swarmName: "",
                 storageName: "",
+                mcpName: "",
             });
         };
         /**
@@ -11036,6 +11273,7 @@ class StatePublicService {
                 agentName: "",
                 swarmName: "",
                 storageName: "",
+                mcpName: "",
             });
         };
         /**
@@ -11063,6 +11301,7 @@ class StatePublicService {
                 agentName: "",
                 swarmName: "",
                 storageName: "",
+                mcpName: "",
             });
         };
         /**
@@ -11091,6 +11330,7 @@ class StatePublicService {
                 agentName: "",
                 swarmName: "",
                 storageName: "",
+                mcpName: "",
             });
         };
     }
@@ -11815,7 +12055,7 @@ class DocService {
                 result.push("```");
                 result.push("");
             }
-            if (agentSchema.system) {
+            if (agentSchema.systemStatic) {
                 result.push(`## System prompt`);
                 result.push("");
                 for (let i = 0; i !== agentSchema.system.length; i++) {
@@ -11826,6 +12066,10 @@ class DocService {
                     result.push("");
                 }
             }
+            if (agentSchema.systemDynamic) {
+                result.push("***Dynamic system prompt found***");
+                result.push("");
+            }
             if (agentSchema.dependsOn) {
                 result.push(`## Depends on`);
                 result.push("");
@@ -12433,6 +12677,7 @@ class SharedStatePublicService {
                 agentName: "",
                 swarmName: "",
                 storageName: "",
+                mcpName: "",
             });
         };
         /**
@@ -12459,6 +12704,7 @@ class SharedStatePublicService {
                 agentName: "",
                 swarmName: "",
                 storageName: "",
+                mcpName: "",
             });
         };
         /**
@@ -12484,6 +12730,7 @@ class SharedStatePublicService {
                 agentName: "",
                 swarmName: "",
                 storageName: "",
+                mcpName: "",
             });
         };
     }
@@ -12541,6 +12788,7 @@ class SharedStoragePublicService {
                 agentName: "",
                 swarmName: "",
                 stateName: "",
+                mcpName: "",
             });
         };
         /**
@@ -12568,6 +12816,7 @@ class SharedStoragePublicService {
                 agentName: "",
                 swarmName: "",
                 stateName: "",
+                mcpName: "",
             });
         };
         /**
@@ -12595,6 +12844,7 @@ class SharedStoragePublicService {
                 agentName: "",
                 swarmName: "",
                 stateName: "",
+                mcpName: "",
             });
         };
         /**
@@ -12623,6 +12873,7 @@ class SharedStoragePublicService {
                 agentName: "",
                 swarmName: "",
                 stateName: "",
+                mcpName: "",
             });
         };
         /**
@@ -12650,6 +12901,7 @@ class SharedStoragePublicService {
                 agentName: "",
                 swarmName: "",
                 stateName: "",
+                mcpName: "",
             });
         };
         /**
@@ -12676,6 +12928,7 @@ class SharedStoragePublicService {
                 agentName: "",
                 swarmName: "",
                 stateName: "",
+                mcpName: "",
             });
         };
     }
@@ -13518,6 +13771,7 @@ class PolicyPublicService {
                 policyName,
                 storageName: "",
                 stateName: "",
+                mcpName: "",
             });
         };
         /**
@@ -13548,6 +13802,7 @@ class PolicyPublicService {
                 policyName,
                 storageName: "",
                 stateName: "",
+                mcpName: "",
             });
         };
         /**
@@ -13580,6 +13835,7 @@ class PolicyPublicService {
                 policyName,
                 storageName: "",
                 stateName: "",
+                mcpName: "",
             });
         };
         /**
@@ -13612,6 +13868,7 @@ class PolicyPublicService {
                 policyName,
                 storageName: "",
                 stateName: "",
+                mcpName: "",
             });
         };
         /**
@@ -13642,6 +13899,7 @@ class PolicyPublicService {
                 policyName,
                 storageName: "",
                 stateName: "",
+                mcpName: "",
             });
         };
         /**
@@ -13672,6 +13930,7 @@ class PolicyPublicService {
                 policyName,
                 storageName: "",
                 stateName: "",
+                mcpName: "",
             });
         };
     }
@@ -14385,6 +14644,239 @@ class WikiValidationService {
     }
 }
 
+class ClientMCP {
+    constructor(params) {
+        this.params = params;
+        this.fetchTools = functoolsKit.memoize(([clientId]) => `${clientId}`, async (clientId) => {
+            GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
+                this.params.logger.debug(`ClientMCP mcpName=${this.params.mcpName} fetchTools`, {
+                    clientId,
+                });
+            const toolList = await this.params.listTools(clientId);
+            return new Map(toolList.map((tool) => [tool.name, tool]));
+        });
+        GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
+            this.params.logger.debug(`ClientMCP mcpName=${this.params.mcpName} CTOR`, {
+                params,
+            });
+        if (this.params.callbacks?.onInit) {
+            this.params.callbacks.onInit();
+        }
+    }
+    async listTools(clientId) {
+        GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
+            this.params.logger.debug(`ClientMCP mcpName=${this.params.mcpName} listTools`, {
+                clientId,
+            });
+        if (this.params.callbacks?.onList) {
+            this.params.callbacks.onList(clientId);
+        }
+        const toolMap = await this.fetchTools(clientId);
+        return Array.from(toolMap.values());
+    }
+    async hasTool(toolName, clientId) {
+        GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
+            this.params.logger.debug(`ClientMCP mcpName=${this.params.mcpName} hasTool`, {
+                toolName,
+                clientId,
+            });
+        const toolMap = await this.fetchTools(clientId);
+        return toolMap.has(toolName);
+    }
+    async callTool(toolName, dto) {
+        GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
+            this.params.logger.debug(`ClientMCP mcpName=${this.params.mcpName} callTool`, {
+                toolName,
+                dto,
+            });
+        if (this.params.callbacks?.onCall) {
+            this.params.callbacks.onCall(toolName, dto);
+        }
+        return await this.params.callTool(toolName, dto);
+    }
+    dispose(clientId) {
+        GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
+            this.params.logger.debug(`ClientMCP mcpName=${this.params.mcpName} dispose`, {
+                clientId,
+            });
+        this.fetchTools.clear(clientId);
+        if (this.params.callbacks?.onDispose) {
+            this.params.callbacks.onDispose(clientId);
+        }
+    }
+}
+
+class MCPConnectionService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.busService = inject(TYPES.busService);
+        this.methodContextService = inject(TYPES.methodContextService);
+        this.mcpSchemaService = inject(TYPES.mcpSchemaService);
+        this.getMCP = functoolsKit.memoize(([mcpName]) => `${mcpName}`, (mcpName) => {
+            const schema = this.mcpSchemaService.get(mcpName);
+            return new ClientMCP({
+                mcpName,
+                bus: this.busService,
+                logger: this.loggerService,
+                ...schema,
+            });
+        });
+    }
+    async listTools(clientId) {
+        GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO &&
+            this.loggerService.info(`mcpConnectionService listTools`, {
+                clientId,
+            });
+        return await this.getMCP(this.methodContextService.context.mcpName).listTools(clientId);
+    }
+    async hasTool(toolName, clientId) {
+        GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO &&
+            this.loggerService.info(`mcpConnectionService hasTool`, {
+                toolName,
+                clientId,
+            });
+        return await this.getMCP(this.methodContextService.context.mcpName).hasTool(toolName, clientId);
+    }
+    async callTool(toolName, dto) {
+        GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO &&
+            this.loggerService.info(`mcpConnectionService hasTool`, {
+                toolName,
+                dto,
+            });
+        return await this.getMCP(this.methodContextService.context.mcpName).callTool(toolName, dto);
+    }
+}
+
+class MCPSchemaService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.registry = new functoolsKit.ToolRegistry("mcpSchemaService");
+        this.validateShallow = (mcpSchema) => {
+            GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO &&
+                this.loggerService.info(`mcpSchemaService validateShallow`, {
+                    mcpSchema,
+                });
+            if (typeof mcpSchema.mcpName !== "string") {
+                throw new Error(`agent-swarm mcp schema validation failed: missing mcpName`);
+            }
+            if (typeof mcpSchema.callTool !== "function") {
+                throw new Error(`agent-swarm mcp schema validation failed: callTool must be provided mcpName=${mcpSchema.mcpName}`);
+            }
+            if (typeof mcpSchema.listTools !== "function") {
+                throw new Error(`agent-swarm mcp schema validation failed: listTools must be provided mcpName=${mcpSchema.mcpName}`);
+            }
+        };
+        this.register = (key, value) => {
+            GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO &&
+                this.loggerService.info(`mcpSchemaService register`, { key });
+            this.validateShallow(value);
+            this.registry = this.registry.register(key, value);
+        };
+        this.override = (key, value) => {
+            GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO &&
+                this.loggerService.info(`mcpSchemaService override`, { key });
+            this.registry = this.registry.override(key, value);
+            return this.registry.get(key);
+        };
+        this.get = (key) => {
+            GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO &&
+                this.loggerService.info(`mcpSchemaService get`, { key });
+            return this.registry.get(key);
+        };
+    }
+}
+
+class MCPPublicService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.mcpConnectionService = inject(TYPES.mcpConnectionService);
+    }
+    async listTools(methodName, clientId, mcpName) {
+        GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO &&
+            this.loggerService.info(`mcpPublicService listTools`, {
+                clientId,
+            });
+        return await MethodContextService.runInContext(async () => {
+            return await this.mcpConnectionService.listTools(clientId);
+        }, {
+            methodName,
+            clientId,
+            mcpName,
+            agentName: "",
+            swarmName: "",
+            storageName: "",
+            stateName: "",
+            policyName: "",
+        });
+    }
+    async hasTool(methodName, clientId, mcpName, toolName) {
+        GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO &&
+            this.loggerService.info(`mcpPublicService hasTool`, {
+                toolName,
+                clientId,
+            });
+        return await MethodContextService.runInContext(async () => {
+            return await this.mcpConnectionService.hasTool(toolName, clientId);
+        }, {
+            methodName,
+            clientId,
+            mcpName,
+            agentName: "",
+            swarmName: "",
+            storageName: "",
+            stateName: "",
+            policyName: "",
+        });
+    }
+    async callTool(methodName, clientId, mcpName, toolName, dto) {
+        GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO &&
+            this.loggerService.info(`mcpPublicService callTool`, {
+                toolName,
+                dto,
+            });
+        return await MethodContextService.runInContext(async () => {
+            return await this.mcpConnectionService.callTool(toolName, dto);
+        }, {
+            methodName,
+            clientId,
+            mcpName,
+            agentName: "",
+            swarmName: "",
+            storageName: "",
+            stateName: "",
+            policyName: "",
+        });
+    }
+}
+
+class MCPValidationService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this._mcpMap = new Map();
+        this.addMCP = (mcpName, mcpSchema) => {
+            GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO &&
+                this.loggerService.info("mcpValidationService addMCP", {
+                    mcpName,
+                    mcpSchema,
+                });
+            if (this._mcpMap.has(mcpName)) {
+                throw new Error(`agent-swarm mcp ${mcpName} already exist`);
+            }
+            this._mcpMap.set(mcpName, mcpSchema);
+        };
+        this.validate = functoolsKit.memoize(([mcpName]) => mcpName, (mcpName, source) => {
+            GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO &&
+                this.loggerService.info("mcpValidationService validate", {
+                    mcpName,
+                    source,
+                });
+            if (!this._mcpMap.has(mcpName)) {
+                throw new Error(`agent-swarm mcp ${mcpName} not found source=${source}`);
+            }
+        });
+    }
+}
+
 {
     provide(TYPES.docService, () => new DocService());
     provide(TYPES.busService, () => new BusService());
@@ -14407,6 +14899,7 @@ class WikiValidationService {
     provide(TYPES.stateConnectionService, () => new StateConnectionService());
     provide(TYPES.sharedStateConnectionService, () => new SharedStateConnectionService());
     provide(TYPES.policyConnectionService, () => new PolicyConnectionService());
+    provide(TYPES.mcpConnectionService, () => new MCPConnectionService());
 }
 {
     provide(TYPES.agentSchemaService, () => new AgentSchemaService());
@@ -14419,6 +14912,7 @@ class WikiValidationService {
     provide(TYPES.memorySchemaService, () => new MemorySchemaService());
     provide(TYPES.policySchemaService, () => new PolicySchemaService());
     provide(TYPES.wikiSchemaService, () => new WikiSchemaService());
+    provide(TYPES.mcpSchemaService, () => new MCPSchemaService());
 }
 {
     provide(TYPES.agentPublicService, () => new AgentPublicService());
@@ -14430,6 +14924,7 @@ class WikiValidationService {
     provide(TYPES.statePublicService, () => new StatePublicService());
     provide(TYPES.sharedStatePublicService, () => new SharedStatePublicService());
     provide(TYPES.policyPublicService, () => new PolicyPublicService());
+    provide(TYPES.mcpPublicService, () => new MCPPublicService());
 }
 {
     provide(TYPES.swarmMetaService, () => new SwarmMetaService());
@@ -14446,6 +14941,7 @@ class WikiValidationService {
     provide(TYPES.policyValidationService, () => new PolicyValidationService());
     provide(TYPES.navigationValidationService, () => new NavigationValidationService());
     provide(TYPES.wikiValidationService, () => new WikiValidationService());
+    provide(TYPES.mcpValidationService, () => new MCPValidationService());
 }
 
 const baseServices = {
@@ -14470,6 +14966,7 @@ const connectionServices = {
     stateConnectionService: inject(TYPES.stateConnectionService),
     sharedStateConnectionService: inject(TYPES.sharedStateConnectionService),
     policyConnectionService: inject(TYPES.policyConnectionService),
+    mcpConnectionService: inject(TYPES.mcpConnectionService),
 };
 const schemaServices = {
     agentSchemaService: inject(TYPES.agentSchemaService),
@@ -14482,6 +14979,7 @@ const schemaServices = {
     memorySchemaService: inject(TYPES.memorySchemaService),
     policySchemaService: inject(TYPES.policySchemaService),
     wikiSchemaService: inject(TYPES.wikiSchemaService),
+    mcpSchemaService: inject(TYPES.mcpSchemaService),
 };
 const publicServices = {
     agentPublicService: inject(TYPES.agentPublicService),
@@ -14493,6 +14991,7 @@ const publicServices = {
     statePublicService: inject(TYPES.statePublicService),
     sharedStatePublicService: inject(TYPES.sharedStatePublicService),
     policyPublicService: inject(TYPES.policyPublicService),
+    mcpPublicService: inject(TYPES.mcpPublicService),
 };
 const metaServices = {
     agentMetaService: inject(TYPES.agentMetaService),
@@ -14509,6 +15008,7 @@ const validationServices = {
     policyValidationService: inject(TYPES.policyValidationService),
     navigationValidationService: inject(TYPES.navigationValidationService),
     wikiValidationService: inject(TYPES.wikiValidationService),
+    mcpValidationService: inject(TYPES.mcpValidationService),
 };
 /** @inheritDoc */
 const swarm = {
@@ -14523,7 +15023,7 @@ const swarm = {
 init();
 var swarm$1 = swarm;
 
-const METHOD_NAME$19 = "cli.dumpDocs";
+const METHOD_NAME$1c = "cli.dumpDocs";
 /**
  * Dumps the documentation for the agents and swarms.
  *
@@ -14533,7 +15033,7 @@ const METHOD_NAME$19 = "cli.dumpDocs";
  */
 const dumpDocs = beginContext((prefix = "swarm", dirName = "./docs/chat", PlantUML) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$19, {
+        swarm$1.loggerService.log(METHOD_NAME$1c, {
             dirName,
         });
     if (PlantUML) {
@@ -14543,10 +15043,10 @@ const dumpDocs = beginContext((prefix = "swarm", dirName = "./docs/chat", PlantU
     }
     swarm$1.agentValidationService
         .getAgentList()
-        .forEach((agentName) => swarm$1.agentValidationService.validate(agentName, METHOD_NAME$19));
+        .forEach((agentName) => swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1c));
     swarm$1.swarmValidationService
         .getSwarmList()
-        .forEach((swarmName) => swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$19));
+        .forEach((swarmName) => swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1c));
     swarm$1.agentValidationService.getAgentList().forEach((agentName) => {
         const { dependsOn } = swarm$1.agentSchemaService.get(agentName);
         if (!dependsOn) {
@@ -14556,7 +15056,7 @@ const dumpDocs = beginContext((prefix = "swarm", dirName = "./docs/chat", PlantU
     return swarm$1.docService.dumpDocs(prefix, dirName);
 });
 
-const METHOD_NAME$18 = "cli.dumpAgent";
+const METHOD_NAME$1b = "cli.dumpAgent";
 /**
  * Dumps the agent information into PlantUML format.
  *
@@ -14565,14 +15065,14 @@ const METHOD_NAME$18 = "cli.dumpAgent";
  */
 const dumpAgent = beginContext((agentName, { withSubtree = false } = {}) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$18, {
+        swarm$1.loggerService.log(METHOD_NAME$1b, {
             agentName,
         });
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$18);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1b);
     return swarm$1.agentMetaService.toUML(agentName, withSubtree);
 });
 
-const METHOD_NAME$17 = "cli.dumpSwarm";
+const METHOD_NAME$1a = "cli.dumpSwarm";
 /**
  * Dumps the swarm information into PlantUML format.
  *
@@ -14581,14 +15081,14 @@ const METHOD_NAME$17 = "cli.dumpSwarm";
  */
 const dumpSwarm = beginContext((swarmName) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$17, {
+        swarm$1.loggerService.log(METHOD_NAME$1a, {
             swarmName,
         });
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$17);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1a);
     return swarm$1.swarmMetaService.toUML(swarmName);
 });
 
-const METHOD_NAME$16 = "cli.dumpPerfomance";
+const METHOD_NAME$19 = "cli.dumpPerfomance";
 const METHOD_NAME_INTERNAL$1 = "cli.dumpPerfomance.internal";
 const METHOD_NAME_INTERVAL = "cli.dumpPerfomance.interval";
 /**
@@ -14607,7 +15107,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$16);
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$19);
     await dumpPerfomanceInternal(dirName);
 };
 /**
@@ -14665,7 +15165,7 @@ const listenExecutionEvent = beginContext((clientId, fn) => {
     return swarm$1.busService.subscribe(clientId, "execution-bus", functoolsKit.queued(async (e) => await fn(e)));
 });
 
-const METHOD_NAME$15 = "cli.dumpClientPerformance";
+const METHOD_NAME$18 = "cli.dumpClientPerformance";
 const METHOD_NAME_INTERNAL = "cli.dumpClientPerformance.internal";
 const METHOD_NAME_EXECUTE = "cli.dumpClientPerformance.execute";
 /**
@@ -14689,7 +15189,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$15);
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$18);
     await dumpClientPerformanceInternal(clientId, dirName);
 };
 /**
@@ -14710,7 +15210,7 @@ dumpClientPerformance.runAfterExecute = beginContext(async (dirName = "./logs/cl
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$14 = "function.commit.commitFlushForce";
+const METHOD_NAME$17 = "function.commit.commitFlushForce";
 /**
  * Forcefully commits a flush of agent history for a specific client in the swarm system, without checking the active agent.
  * Validates the session and swarm, then proceeds with flushing the history regardless of the current agent state.
@@ -14728,20 +15228,20 @@ const METHOD_NAME$14 = "function.commit.commitFlushForce";
 const commitFlushForce = beginContext(async (clientId) => {
     // Log the flush attempt if enabled
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$14, {
+        swarm$1.loggerService.log(METHOD_NAME$17, {
             clientId,
-            METHOD_NAME: METHOD_NAME$14,
+            METHOD_NAME: METHOD_NAME$17,
         });
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$14);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$17);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$14);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$17);
     // Commit the flush of agent history via SessionPublicService without agent checks
-    await swarm$1.sessionPublicService.commitFlush(METHOD_NAME$14, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitFlush(METHOD_NAME$17, clientId, swarmName);
 });
 
-const METHOD_NAME$13 = "function.commit.commitToolOutputForce";
+const METHOD_NAME$16 = "function.commit.commitToolOutputForce";
 /**
  * Commits the output of a tool execution to the active agent in a swarm session without checking the active agent.
  *
@@ -14760,24 +15260,24 @@ const METHOD_NAME$13 = "function.commit.commitToolOutputForce";
 const commitToolOutputForce = beginContext(async (toolId, content, clientId) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$13, {
+        swarm$1.loggerService.log(METHOD_NAME$16, {
             toolId,
             content,
             clientId,
         });
     // Validate the session and swarm to ensure they exist and are accessible
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$13);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$16);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$13);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$16);
     // 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$13, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitToolOutput(toolId, content, METHOD_NAME$16, clientId, swarmName);
 });
 
 /**
  * @private Constant defining the method name for logging and validation purposes.
  * Used as an identifier in log messages and validation checks to track calls to `hasNavigation`.
  */
-const METHOD_NAME$12 = "function.common.hasNavigation";
+const METHOD_NAME$15 = "function.common.hasNavigation";
 /**
  * Checks if a specific agent is part of the navigation route for a given client.
  * Validates the agent and client session, retrieves the associated swarm, and queries the navigation route.
@@ -14788,16 +15288,16 @@ const METHOD_NAME$12 = "function.common.hasNavigation";
  */
 const hasNavigation = async (clientId, agentName) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$12, { clientId });
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$12);
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$12);
+        swarm$1.loggerService.log(METHOD_NAME$15, { clientId });
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$15);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$15);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     return swarm$1.navigationValidationService
         .getNavigationRoute(clientId, swarmName)
         .has(agentName);
 };
 
-const METHOD_NAME$11 = "function.history.getRawHistory";
+const METHOD_NAME$14 = "function.history.getRawHistory";
 /**
  * Retrieves the raw, unmodified history for a given client session.
  *
@@ -14814,10 +15314,10 @@ const METHOD_NAME$11 = "function.history.getRawHistory";
  * const rawHistory = await getRawHistory("client-123");
  * console.log(rawHistory); // Outputs the full raw history array
  */
-const getRawHistory = beginContext(async (clientId, methodName = METHOD_NAME$11) => {
+const getRawHistory = beginContext(async (clientId, methodName = METHOD_NAME$14) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$11, {
+        swarm$1.loggerService.log(METHOD_NAME$14, {
             clientId,
         });
     // Validate the session and swarm
@@ -14830,7 +15330,7 @@ const getRawHistory = beginContext(async (clientId, methodName = METHOD_NAME$11)
     return [...history];
 });
 
-const METHOD_NAME$10 = "function.history.getLastUserMessage";
+const METHOD_NAME$13 = "function.history.getLastUserMessage";
 /**
  * Retrieves the content of the most recent user message from a client's session history.
  *
@@ -14848,16 +15348,16 @@ const METHOD_NAME$10 = "function.history.getLastUserMessage";
 const getLastUserMessage = beginContext(async (clientId) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$10, {
+        swarm$1.loggerService.log(METHOD_NAME$13, {
             clientId,
         });
     // Fetch raw history and find the last user message
-    const history = await getRawHistory(clientId, METHOD_NAME$10);
+    const history = await getRawHistory(clientId, METHOD_NAME$13);
     const last = history.findLast(({ role, mode }) => role === "user" && mode === "user");
     return last ? last.content : null;
 });
 
-const METHOD_NAME$$ = "function.navigate.changeToDefaultAgent";
+const METHOD_NAME$12 = "function.navigate.changeToDefaultAgent";
 /**
  * Time-to-live for the change agent function in milliseconds.
  * Defines how long the cached change agent function remains valid before expiring.
@@ -14892,7 +15392,7 @@ const createChangeToDefaultAgent = functoolsKit.ttl((clientId) => functoolsKit.q
     }));
     {
         // Dispose of the current agent's resources and set up the new default agent
-        const agentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$$, clientId, swarmName);
+        const agentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$12, 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));
@@ -14931,23 +15431,23 @@ const createGc$3 = functoolsKit.singleshot(async () => {
 const changeToDefaultAgent = beginContext(async (clientId) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$$, {
+        swarm$1.loggerService.log(METHOD_NAME$12, {
             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$$);
-        swarm$1.agentValidationService.validate(agentName, METHOD_NAME$$);
+        swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$12);
+        swarm$1.agentValidationService.validate(agentName, METHOD_NAME$12);
     }
     // Execute the agent change with TTL and queuing
     const run = await createChangeToDefaultAgent(clientId);
     createGc$3();
-    return await run(METHOD_NAME$$, agentName, swarmName);
+    return await run(METHOD_NAME$12, agentName, swarmName);
 });
 
-const METHOD_NAME$_ = "function.target.emitForce";
+const METHOD_NAME$11 = "function.target.emitForce";
 /**
  * Emits a string as model output without executing an incoming message or checking the active agent.
  *
@@ -14966,19 +15466,19 @@ const METHOD_NAME$_ = "function.target.emitForce";
 const emitForce = beginContext(async (content, clientId) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$_, {
+        swarm$1.loggerService.log(METHOD_NAME$11, {
             content,
             clientId,
         });
     // Validate the session and swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$_);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$11);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$_);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$11);
     // Emit the content directly via the session public service
-    return await swarm$1.sessionPublicService.emit(content, METHOD_NAME$_, clientId, swarmName);
+    return await swarm$1.sessionPublicService.emit(content, METHOD_NAME$11, clientId, swarmName);
 });
 
-const METHOD_NAME$Z = "function.target.executeForce";
+const METHOD_NAME$10 = "function.target.executeForce";
 /**
  * Sends a message to the active agent in a swarm session as if it originated from the client side, forcing execution regardless of agent activity.
  *
@@ -14999,22 +15499,22 @@ const executeForce = beginContext(async (content, clientId) => {
     const executionId = functoolsKit.randomString();
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$Z, {
+        swarm$1.loggerService.log(METHOD_NAME$10, {
             content,
             clientId,
             executionId,
         });
     // Validate the session and swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$Z);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$10);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$Z);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$10);
     // 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$Z, clientId, swarmName);
+            const result = await swarm$1.sessionPublicService.execute(content, "tool", METHOD_NAME$10, clientId, swarmName);
             isFinished = swarm$1.perfService.endExecution(executionId, clientId, result.length);
             swarm$1.busService.commitExecutionEnd(clientId, { swarmName });
             return result;
@@ -15031,7 +15531,7 @@ const executeForce = beginContext(async (content, clientId) => {
     });
 });
 
-const METHOD_NAME$Y = "function.template.navigateToTriageAgent";
+const METHOD_NAME$$ = "function.template.navigateToTriageAgent";
 const DEFAULT_ACCEPT_FN = (_, defaultAgent) => `Successfully navigated to ${defaultAgent}`;
 const DEFAULT_REJECT_FN = (_, defaultAgent) => `Already on ${defaultAgent}`;
 /**
@@ -15080,7 +15580,7 @@ const createNavigateToTriageAgent = async ({ flushMessage, executeMessage, toolO
      */
     return beginContext(async (toolId, clientId) => {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-            swarm$1.loggerService.log(METHOD_NAME$Y, {
+            swarm$1.loggerService.log(METHOD_NAME$$, {
                 clientId,
                 toolId,
             });
@@ -15110,55 +15610,258 @@ const createNavigateToTriageAgent = async ({ flushMessage, executeMessage, toolO
     });
 };
 
-/** @constant {string} METHOD_NAME - The name of the method used for logging */
-const METHOD_NAME$X = "function.setup.addWiki";
+const METHOD_NAME$_ = "function.navigate.changeToAgent";
 /**
- * Adds a wiki schema to the system
- * @function addWiki
- * @param {IWikiSchema} wikiSchema - The wiki schema to add
- * @returns {string} The name of the added wiki
+ * Time-to-live for the change agent function in milliseconds.
+ * Defines how long the cached change agent function remains valid before expiring.
+ * @constant {number}
  */
-const addWiki = beginContext((wikiSchema) => {
-    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$X, {
-            wikiSchema,
-        });
-    swarm$1.wikiValidationService.addWiki(wikiSchema.wikiName, wikiSchema);
-    swarm$1.wikiSchemaService.register(wikiSchema.wikiName, wikiSchema);
-    return wikiSchema.wikiName;
-});
-
-const METHOD_NAME$W = "function.setup.addAgent";
+const CHANGE_AGENT_TTL$1 = 15 * 60 * 1000;
 /**
- * Adds a new agent to the agent registry for use within the swarm system.
+ * Garbage collection interval for the change agent function in milliseconds.
+ * Specifies the frequency at which expired TTL entries are cleaned up.
+ * @constant {number}
+ */
+const CHANGE_AGENT_GC$1 = 60 * 1000;
+/**
+ * Creates a change agent function with time-to-live (TTL) and queuing capabilities.
  *
- * This function registers a new agent by adding it to the agent validation and schema services, making it available for swarm operations.
- * Only agents registered through this function can be utilized by the swarm. The execution is wrapped in `beginContext` to ensure it runs
- * outside of existing method and execution contexts, providing a clean execution environment. The function logs the operation if enabled
- * and returns the agent's name upon successful registration.
+ * This factory function generates a queued, TTL-limited function to handle agent changes for a specific client session,
+ * ensuring operations are executed sequentially and cached results are reused within the TTL period.
  *
- * @param {IAgentSchema} agentSchema - The schema defining the agent's properties, including its name (`agentName`) and other configuration details.
- * @returns {string} The name of the newly added agent (`agentSchema.agentName`), confirming its registration.
- * @throws {Error} If the agent schema is invalid or if registration fails due to conflicts or service errors (e.g., duplicate agent name).
- * @example
- * const agentSchema = { agentName: "AgentX", prompt: "Handle tasks" };
- * const agentName = addAgent(agentSchema);
- * console.log(agentName); // Outputs "AgentX"
+ * @function
+ * @param {string} clientId - The unique identifier of the client session.
+ * @returns {TChangeToAgentRun} A function that performs the agent change operation with queuing and TTL.
  */
-const addAgent = beginContext((agentSchema) => {
-    // Log the operation details if logging is enabled in GLOBAL_CONFIG
-    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$W, {
-            agentSchema,
-        });
-    // Register the agent in the validation and schema services
-    swarm$1.agentValidationService.addAgent(agentSchema.agentName, agentSchema);
+const createChangeToAgent = functoolsKit.ttl((clientId) => functoolsKit.queued(async (methodName, agentName, swarmName) => {
+    if (!swarm$1.navigationValidationService.shouldNavigate(agentName, clientId, swarmName)) {
+        console.warn(`function "changeToAgent" skipped due to the circular route found clientId=${clientId} swarmName=${swarmName} agentNameTo=${agentName}`);
+        return false;
+    }
+    // Notify all agents in the swarm of the change
+    await Promise.all(swarm$1.swarmValidationService
+        .getAgentList(swarmName)
+        .map(async (agentName) => {
+        await swarm$1.agentPublicService.commitAgentChange(methodName, clientId, agentName);
+    }));
+    {
+        // Dispose of the current agent's resources and set up the new agent
+        const agentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$_, clientId, swarmName);
+        await swarm$1.agentPublicService.dispose(methodName, clientId, agentName);
+        await swarm$1.historyPublicService.dispose(methodName, clientId, agentName);
+        await swarm$1.swarmPublicService.setAgentRef(methodName, clientId, swarmName, agentName, await swarm$1.agentPublicService.createAgentRef(methodName, clientId, agentName));
+    }
+    // Set the new agent as the active agent
+    await swarm$1.swarmPublicService.setAgentName(agentName, methodName, clientId, swarmName);
+    return true;
+}), {
+    key: ([clientId]) => `${clientId}`,
+    timeout: CHANGE_AGENT_TTL$1,
+});
+/**
+ * Creates a garbage collector for the change agent function.
+ *
+ * This function sets up a singleton interval-based garbage collector to periodically clean up expired TTL entries from `createChangeToAgent`.
+ *
+ * @function
+ * @returns {Promise<void>} A promise that resolves when the garbage collector is initialized.
+ */
+const createGc$2 = functoolsKit.singleshot(async () => {
+    setInterval(createChangeToAgent.gc, CHANGE_AGENT_GC$1);
+});
+/**
+ * Changes the active agent for a given client session in a swarm.
+ *
+ * This function facilitates switching the active agent in a swarm session, validating the session and agent dependencies,
+ * logging the operation if enabled, and executing the change using a TTL-limited, queued runner.
+ * The execution is wrapped in `beginContext` to ensure it runs outside of existing method and execution contexts.
+ *
+ * @param {AgentName} agentName - The name of the agent to switch to.
+ * @param {string} clientId - The unique identifier of the client session.
+ * @returns {Promise<boolean>} A promise that resolves when the agent change is complete. If it resolved false, the navigation is canceled due to recursion
+ * @throws {Error} If session or agent validation fails, or if the agent change process encounters an error.
+ * @example
+ * await changeToAgent("AgentX", "client-123");
+ */
+const changeToAgent = beginContext(async (agentName, clientId) => {
+    // Log the operation details if logging is enabled in GLOBAL_CONFIG
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
+        swarm$1.loggerService.log(METHOD_NAME$_, {
+            agentName,
+            clientId,
+        });
+    const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
+    {
+        // Validate session, agent, and dependencies
+        swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$_);
+        swarm$1.agentValidationService.validate(agentName, METHOD_NAME$_);
+        const activeAgent = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$_, clientId, swarmName);
+        if (!swarm$1.agentValidationService.hasDependency(activeAgent, agentName)) {
+            console.error(`agent-swarm missing dependency detected for activeAgent=${activeAgent} dependencyAgent=${agentName}`);
+        }
+    }
+    if (!swarm$1.swarmValidationService.getAgentSet(swarmName).has(agentName)) {
+        GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
+            swarm$1.loggerService.log('function "changeToAgent" skipped due to the agent is not in the swarm', {
+                agentName,
+                clientId,
+                swarmName,
+            });
+        console.warn(`function "changeToAgent" skipped due to the agent is not in the swarm clientId=${clientId} agentName=${agentName} swarmName=${swarmName}`);
+        return false;
+    }
+    // Execute the agent change with TTL and queuing
+    const run = await createChangeToAgent(clientId);
+    createGc$2();
+    return await run(METHOD_NAME$_, agentName, swarmName);
+});
+
+const METHOD_NAME$Z = "function.template.navigateToAgent";
+/**
+ * Default tool output message indicating successful navigation to the specified agent.
+ *
+ * @param {SessionId} _ - The client session ID (unused).
+ * @param {AgentName} agentName - The name of the agent navigated to.
+ * @returns {string} A message confirming navigation to the agent.
+ */
+const DEFAULT_TOOL_OUTPUT = (_, agentName) => `Successfully navigated to ${agentName}`;
+/**
+ * Default flush message prompting the user to repeat their input.
+ *
+ * @param {SessionId} _ - The client session ID (unused).
+ * @param {AgentName} _ - The agent name (unused).
+ * @returns {string} A generic retry message.
+ */
+const DEFAULT_FLUSH_MESSAGE = ({}, {}) => `Sorry, I missed that. Could you repeat please`;
+/**
+ * Creates a function to navigate to a specified agent for a given client, handling navigation, message execution, emission, and tool output.
+ * The factory generates a handler that checks navigation state, retrieves the last user message, commits tool outputs, and triggers execution or emission based on provided parameters.
+ * It validates the presence of either `emitMessage` or `executeMessage` to ensure proper navigation behavior.
+ * Logs the navigation operation if logging is enabled in the global configuration.
+ *
+ * @param {IFactoryParams} params - Configuration parameters for the navigation handler.
+ * @param {string | ((clientId: string, defaultAgent: AgentName) => string | Promise<string>)} [params.flushMessage] - Optional message or function to emit after flushing the session, defaults to `DEFAULT_FLUSH_MESSAGE`.
+ * @param {string | ((clientId: string, agentName: AgentName) => string | Promise<string>)} [params.toolOutput] - Optional message or function for tool output when navigation occurs, defaults to `DEFAULT_TOOL_OUTPUT`.
+ * @param {string | ((clientId: string, lastMessage: string, agentName: AgentName) => string | Promise<string>)} [params.emitMessage] - Optional message or function to emit when navigation occurs without execution.
+ * @param {string | ((clientId: string, lastMessage: string, agentName: AgentName) => string | Promise<string>)} [params.executeMessage] - Optional message or function to execute when navigation occurs with execution.
+ * @returns {Promise<(toolId: string, clientId: string, agentName: AgentName) => Promise<void>>} A promise resolving to a function that handles navigation to the specified agent.
+ * @throws {Error} If neither `emitMessage` nor `executeMessage` is provided, or if any internal operation (e.g., navigation, commit, or execution) fails.
+ *
+ * @example
+ * // Create a navigation handler with static messages
+ * const navigate = await createNavigateToAgent({
+ *   flushMessage: "Session reset.",
+ *   toolOutput: "Navigation completed.",
+ *   emitMessage: "Navigation event triggered.",
+ * });
+ * await navigate("tool-123", "client-456", "WeatherAgent");
+ * // Navigates to WeatherAgent, commits tool output, and emits the message.
+ *
+ * @example
+ * // Create a navigation handler with dynamic messages
+ * const navigate = await createNavigateToAgent({
+ *   executeMessage: (clientId, lastMessage, agent) => `Processing ${lastMessage} for ${clientId} on ${agent}`,
+ *   toolOutput: (clientId, agent) => `Navigated ${clientId} to ${agent}`,
+ * });
+ * await navigate("tool-789", "client-012", "SupportAgent");
+ * // Navigates to SupportAgent, commits dynamic tool output, and executes the message with the last user message.
+ */
+const createNavigateToAgent = async ({ executeMessage, emitMessage, flushMessage = DEFAULT_FLUSH_MESSAGE, toolOutput = DEFAULT_TOOL_OUTPUT, }) => {
+    if (!emitMessage && !executeMessage) {
+        throw new Error("agent-swarm createNavigateToAgent emitMessage or executeMessage required");
+    }
+    /**
+     * Navigates to a specified agent for a given client and tool, handling message commits, execution, or emission using the last user message.
+     *
+     * @param {string} toolId - The identifier of the tool triggering the navigation.
+     * @param {string} clientId - The unique identifier of the client session.
+     * @param {AgentName} agentName - The name of the agent to navigate to.
+     * @returns {Promise<void>} A promise that resolves when the navigation and associated actions are complete.
+     * @throws {Error} If navigation, commit, execution, or emission operations fail (e.g., invalid clientId or agentName).
+     */
+    return beginContext(async (toolId, clientId, agentName) => {
+        GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
+            swarm$1.loggerService.log(METHOD_NAME$Z, {
+                clientId,
+                toolId,
+            });
+        const lastMessage = await getLastUserMessage(clientId);
+        if (await functoolsKit.and(functoolsKit.not(hasNavigation(clientId, agentName)), Promise.resolve(!!executeMessage))) {
+            await commitToolOutputForce(toolId, typeof toolOutput === "string"
+                ? toolOutput
+                : await toolOutput(clientId, agentName), clientId);
+            await changeToAgent(agentName, clientId);
+            await executeForce(typeof executeMessage === "string"
+                ? executeMessage
+                : await executeMessage(clientId, lastMessage, agentName), clientId);
+            return;
+        }
+        if (await functoolsKit.and(functoolsKit.not(hasNavigation(clientId, agentName)), Promise.resolve(!!emitMessage))) {
+            await commitToolOutputForce(toolId, typeof toolOutput === "string"
+                ? toolOutput
+                : await toolOutput(clientId, agentName), clientId);
+            await changeToAgent(agentName, clientId);
+            await emitForce(typeof emitMessage === "string"
+                ? emitMessage
+                : await emitMessage(clientId, lastMessage, agentName), clientId);
+            return;
+        }
+        await commitFlushForce(clientId);
+        await emitForce(typeof flushMessage === "string"
+            ? flushMessage
+            : await flushMessage(clientId, agentName), clientId);
+    });
+};
+
+/** @constant {string} METHOD_NAME - The name of the method used for logging */
+const METHOD_NAME$Y = "function.setup.addWiki";
+/**
+ * Adds a wiki schema to the system
+ * @function addWiki
+ * @param {IWikiSchema} wikiSchema - The wiki schema to add
+ * @returns {string} The name of the added wiki
+ */
+const addWiki = beginContext((wikiSchema) => {
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
+        swarm$1.loggerService.log(METHOD_NAME$Y, {
+            wikiSchema,
+        });
+    swarm$1.wikiValidationService.addWiki(wikiSchema.wikiName, wikiSchema);
+    swarm$1.wikiSchemaService.register(wikiSchema.wikiName, wikiSchema);
+    return wikiSchema.wikiName;
+});
+
+const METHOD_NAME$X = "function.setup.addAgent";
+/**
+ * Adds a new agent to the agent registry for use within the swarm system.
+ *
+ * This function registers a new agent by adding it to the agent validation and schema services, making it available for swarm operations.
+ * Only agents registered through this function can be utilized by the swarm. The execution is wrapped in `beginContext` to ensure it runs
+ * outside of existing method and execution contexts, providing a clean execution environment. The function logs the operation if enabled
+ * and returns the agent's name upon successful registration.
+ *
+ * @param {IAgentSchema} agentSchema - The schema defining the agent's properties, including its name (`agentName`) and other configuration details.
+ * @returns {string} The name of the newly added agent (`agentSchema.agentName`), confirming its registration.
+ * @throws {Error} If the agent schema is invalid or if registration fails due to conflicts or service errors (e.g., duplicate agent name).
+ * @example
+ * const agentSchema = { agentName: "AgentX", prompt: "Handle tasks" };
+ * const agentName = addAgent(agentSchema);
+ * console.log(agentName); // Outputs "AgentX"
+ */
+const addAgent = beginContext((agentSchema) => {
+    // Log the operation details if logging is enabled in GLOBAL_CONFIG
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
+        swarm$1.loggerService.log(METHOD_NAME$X, {
+            agentSchema,
+        });
+    // Register the agent in the validation and schema services
+    swarm$1.agentValidationService.addAgent(agentSchema.agentName, agentSchema);
     swarm$1.agentSchemaService.register(agentSchema.agentName, agentSchema);
     // Return the agent's name as confirmation of registration
     return agentSchema.agentName;
 });
 
-const METHOD_NAME$V = "function.setup.addCompletion";
+const METHOD_NAME$W = "function.setup.addCompletion";
 /**
  * Adds a completion engine to the registry for use by agents in the swarm system.
  *
@@ -15178,7 +15881,7 @@ const METHOD_NAME$V = "function.setup.addCompletion";
 const addCompletion = beginContext((completionSchema) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$V, {
+        swarm$1.loggerService.log(METHOD_NAME$W, {
             completionSchema,
         });
     // Register the completion in the validation and schema services
@@ -15188,7 +15891,7 @@ const addCompletion = beginContext((completionSchema) => {
     return completionSchema.completionName;
 });
 
-const METHOD_NAME$U = "function.setup.addSwarm";
+const METHOD_NAME$V = "function.setup.addSwarm";
 /**
  * Adds a new swarm to the system for managing client sessions.
  *
@@ -15208,7 +15911,7 @@ const METHOD_NAME$U = "function.setup.addSwarm";
 const addSwarm = beginContext((swarmSchema) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$U, {
+        swarm$1.loggerService.log(METHOD_NAME$V, {
             swarmSchema,
         });
     // Register the swarm in the validation and schema services
@@ -15218,7 +15921,7 @@ const addSwarm = beginContext((swarmSchema) => {
     return swarmSchema.swarmName;
 });
 
-const METHOD_NAME$T = "function.setup.addTool";
+const METHOD_NAME$U = "function.setup.addTool";
 /**
  * Adds a new tool to the tool registry for use by agents in the swarm system.
  *
@@ -15240,7 +15943,7 @@ const METHOD_NAME$T = "function.setup.addTool";
 const addTool = beginContext((toolSchema) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$T, {
+        swarm$1.loggerService.log(METHOD_NAME$U, {
             toolSchema,
         });
     // Register the tool in the validation and schema services
@@ -15250,6 +15953,17 @@ const addTool = beginContext((toolSchema) => {
     return toolSchema.toolName;
 });
 
+const METHOD_NAME$T = "function.setup.addMCP";
+const addMCP = beginContext((mcpSchema) => {
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
+        swarm$1.loggerService.log(METHOD_NAME$T, {
+            mcpSchema,
+        });
+    swarm$1.mcpValidationService.addMCP(mcpSchema.mcpName, mcpSchema);
+    swarm$1.mcpSchemaService.register(mcpSchema.mcpName, mcpSchema);
+    return mcpSchema.mcpName;
+});
+
 const METHOD_NAME$S = "function.setup.addState";
 /**
  * Adds a new state to the state registry for use within the swarm system.
@@ -15628,7 +16342,16 @@ const overrideTool = beginContext((toolSchema) => {
     return swarm$1.toolSchemaService.override(toolSchema.toolName, toolSchema);
 });
 
-const METHOD_NAME$G = "function.test.overrideWiki";
+const METHOD_NAME$G = "function.test.overrideMCP";
+const overrideMCP = beginContext((mcpSchema) => {
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
+        swarm$1.loggerService.log(METHOD_NAME$G, {
+            mcpSchema,
+        });
+    return swarm$1.mcpSchemaService.override(mcpSchema.mcpName, mcpSchema);
+});
+
+const METHOD_NAME$F = "function.test.overrideWiki";
 /**
  * Overrides an existing wiki schema in the swarm system with a new or partial schema.
  * This function updates the configuration of a wiki identified by its `wikiName`, applying the provided schema properties.
@@ -15652,13 +16375,13 @@ const METHOD_NAME$G = "function.test.overrideWiki";
  */
 const overrideWiki = beginContext((wikiSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$G, {
+        swarm$1.loggerService.log(METHOD_NAME$F, {
             wikiSchema,
         });
     return swarm$1.wikiSchemaService.override(wikiSchema.wikiName, wikiSchema);
 });
 
-const METHOD_NAME$F = "function.other.markOnline";
+const METHOD_NAME$E = "function.other.markOnline";
 /**
  * Marks a client as online in the specified swarm.
  *
@@ -15670,26 +16393,27 @@ const METHOD_NAME$F = "function.other.markOnline";
 const markOnline = async (clientId, swarmName) => {
     // Log the operation if logging is enabled in the global configuration
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm.loggerService.log(METHOD_NAME$F, {
+        swarm.loggerService.log(METHOD_NAME$E, {
             clientId,
         });
     // Validate the swarm name
-    swarm.swarmValidationService.validate(swarmName, METHOD_NAME$F);
+    swarm.swarmValidationService.validate(swarmName, METHOD_NAME$E);
     // Run the operation in the method context
     return await MethodContextService.runInContext(async () => {
-        await swarm.aliveService.markOnline(clientId, swarmName, METHOD_NAME$F);
+        await swarm.aliveService.markOnline(clientId, swarmName, METHOD_NAME$E);
     }, {
-        methodName: METHOD_NAME$F,
+        methodName: METHOD_NAME$E,
         agentName: "",
         policyName: "",
         stateName: "",
         storageName: "",
+        mcpName: "",
         swarmName,
         clientId,
     });
 };
 
-const METHOD_NAME$E = "function.other.markOffline";
+const METHOD_NAME$D = "function.other.markOffline";
 /**
  * Marks a client as offline in the specified swarm.
  *
@@ -15704,24 +16428,25 @@ const METHOD_NAME$E = "function.other.markOffline";
  */
 const markOffline = async (clientId, swarmName) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm.loggerService.log(METHOD_NAME$E, {
+        swarm.loggerService.log(METHOD_NAME$D, {
             clientId,
         });
-    swarm.swarmValidationService.validate(swarmName, METHOD_NAME$E);
+    swarm.swarmValidationService.validate(swarmName, METHOD_NAME$D);
     return await MethodContextService.runInContext(async () => {
-        await swarm.aliveService.markOffline(clientId, swarmName, METHOD_NAME$E);
+        await swarm.aliveService.markOffline(clientId, swarmName, METHOD_NAME$D);
     }, {
-        methodName: METHOD_NAME$E,
+        methodName: METHOD_NAME$D,
         agentName: "",
         policyName: "",
         stateName: "",
         storageName: "",
+        mcpName: "",
         swarmName,
         clientId,
     });
 };
 
-const METHOD_NAME$D = "function.commit.commitToolOutput";
+const METHOD_NAME$C = "function.commit.commitToolOutput";
 /**
  * Commits the output of a tool execution to the active agent in a swarm session.
  *
@@ -15741,19 +16466,19 @@ const METHOD_NAME$D = "function.commit.commitToolOutput";
 const commitToolOutput = beginContext(async (toolId, content, clientId, agentName) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$D, {
+        swarm$1.loggerService.log(METHOD_NAME$C, {
             toolId,
             content,
             clientId,
             agentName,
         });
     // Validate the agent, session, and swarm to ensure they exist and are accessible
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$D);
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$D);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$C);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$C);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$D);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$C);
     // Check if the specified agent is still the active agent in the swarm session
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$D, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$C, clientId, swarmName);
     if (currentAgentName !== agentName) {
         // Log a skip message if the agent has changed during the operation
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
@@ -15766,11 +16491,11 @@ const commitToolOutput = beginContext(async (toolId, content, clientId, agentNam
         return;
     }
     // Commit the tool output to the session via the session public service
-    await swarm$1.sessionPublicService.commitToolOutput(toolId, content, METHOD_NAME$D, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitToolOutput(toolId, content, METHOD_NAME$C, clientId, swarmName);
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$C = "function.commit.commitSystemMessage";
+const METHOD_NAME$B = "function.commit.commitSystemMessage";
 /**
  * Commits a system-generated message to the active agent in the swarm system.
  * Validates the agent, session, and swarm, ensuring the current agent matches the provided agent before committing the message.
@@ -15789,20 +16514,20 @@ const METHOD_NAME$C = "function.commit.commitSystemMessage";
 const commitSystemMessage = beginContext(async (content, clientId, agentName) => {
     // Log the commit attempt if enabled
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$C, {
+        swarm$1.loggerService.log(METHOD_NAME$B, {
             content,
             clientId,
             agentName,
         });
     // Validate the agent exists
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$C);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$B);
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$C);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$B);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$C);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$B);
     // Check if the current agent matches the provided agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$C, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$B, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "commitSystemMessage" skipped due to the agent change', {
@@ -15813,11 +16538,11 @@ const commitSystemMessage = beginContext(async (content, clientId, agentName) =>
         return;
     }
     // Commit the system message via SessionPublicService
-    await swarm$1.sessionPublicService.commitSystemMessage(content, METHOD_NAME$C, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitSystemMessage(content, METHOD_NAME$B, clientId, swarmName);
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$B = "function.commit.commitFlush";
+const METHOD_NAME$A = "function.commit.commitFlush";
 /**
  * Commits a flush of agent history for a specific client and agent in the swarm system.
  * Validates the agent, session, and swarm, ensuring the current agent matches the provided agent before flushing the history.
@@ -15834,19 +16559,19 @@ const METHOD_NAME$B = "function.commit.commitFlush";
 const commitFlush = beginContext(async (clientId, agentName) => {
     // Log the flush attempt if enabled
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$B, {
+        swarm$1.loggerService.log(METHOD_NAME$A, {
             clientId,
             agentName,
         });
     // Validate the agent exists
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$B);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$A);
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$B);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$A);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$B);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$A);
     // Check if the current agent matches the provided agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$B, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$A, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "commitFlush" skipped due to the agent change', {
@@ -15857,10 +16582,10 @@ const commitFlush = beginContext(async (clientId, agentName) => {
         return;
     }
     // Commit the flush of agent history via SessionPublicService
-    await swarm$1.sessionPublicService.commitFlush(METHOD_NAME$B, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitFlush(METHOD_NAME$A, clientId, swarmName);
 });
 
-const METHOD_NAME$A = "function.commit.commitSystemMessage";
+const METHOD_NAME$z = "function.commit.commitSystemMessage";
 /**
  * Commits a user message to the active agent's history in a swarm session without triggering a response.
  *
@@ -15879,19 +16604,19 @@ const METHOD_NAME$A = "function.commit.commitSystemMessage";
 const commitUserMessage = beginContext(async (content, mode, clientId, agentName, payload) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$A, {
+        swarm$1.loggerService.log(METHOD_NAME$z, {
             content,
             clientId,
             agentName,
             mode,
         });
     // Validate the agent, session, and swarm to ensure they exist and are accessible
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$A);
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$A);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$z);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$z);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$A);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$z);
     // Check if the specified agent is still the active agent in the swarm session
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$A, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$z, clientId, swarmName);
     if (currentAgentName !== agentName) {
         // Log a skip message if the agent has changed during the operation
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
@@ -15904,18 +16629,18 @@ const commitUserMessage = beginContext(async (content, mode, clientId, agentName
     }
     if (payload) {
         return await PayloadContextService.runInContext(async () => {
-            await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$A, clientId, swarmName);
+            await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$z, clientId, swarmName);
         }, {
             clientId,
             payload,
         });
     }
     // Commit the user message to the agent's history via the session public service
-    return await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$A, clientId, swarmName);
+    return await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$z, clientId, swarmName);
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$z = "function.commit.commitSystemMessageForce";
+const METHOD_NAME$y = "function.commit.commitSystemMessageForce";
 /**
  * Forcefully commits a system-generated message to a session in the swarm system, without checking the active agent.
  * Validates the session and swarm, then proceeds with committing the message regardless of the current agent state.
@@ -15934,20 +16659,20 @@ const METHOD_NAME$z = "function.commit.commitSystemMessageForce";
 const commitSystemMessageForce = beginContext(async (content, clientId) => {
     // Log the commit attempt if enabled
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$z, {
+        swarm$1.loggerService.log(METHOD_NAME$y, {
             content,
             clientId,
         });
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$z);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$y);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$z);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$y);
     // Commit the system message via SessionPublicService without agent checks
-    await swarm$1.sessionPublicService.commitSystemMessage(content, METHOD_NAME$z, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitSystemMessage(content, METHOD_NAME$y, clientId, swarmName);
 });
 
-const METHOD_NAME$y = "function.commit.commitSystemMessage";
+const METHOD_NAME$x = "function.commit.commitSystemMessage";
 /**
  * Commits a user message to the active agent's history in a swarm session without triggering a response and without checking the active agent.
  *
@@ -15965,29 +16690,29 @@ const METHOD_NAME$y = "function.commit.commitSystemMessage";
 const commitUserMessageForce = beginContext(async (content, mode, clientId, payload) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$y, {
+        swarm$1.loggerService.log(METHOD_NAME$x, {
             content,
             clientId,
             mode,
         });
     // Validate the session and swarm to ensure they exist and are accessible
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$y);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$x);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$y);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$x);
     if (payload) {
         return await PayloadContextService.runInContext(async () => {
-            await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$y, clientId, swarmName);
+            await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$x, clientId, swarmName);
         }, {
             clientId,
             payload,
         });
     }
     // Commit the user message to the agent's history via the session public service without checking the active agent
-    return await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$y, clientId, swarmName);
+    return await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$x, clientId, swarmName);
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$x = "function.commit.commitAssistantMessage";
+const METHOD_NAME$w = "function.commit.commitAssistantMessage";
 /**
  * Commits an assistant-generated message to the active agent in the swarm system.
  * Validates the agent, session, and swarm, ensuring the current agent matches the provided agent before committing the message.
@@ -16005,20 +16730,20 @@ const METHOD_NAME$x = "function.commit.commitAssistantMessage";
 const commitAssistantMessage = beginContext(async (content, clientId, agentName) => {
     // Log the commit attempt if enabled
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$x, {
+        swarm$1.loggerService.log(METHOD_NAME$w, {
             content,
             clientId,
             agentName,
         });
     // Validate the agent exists
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$x);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$w);
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$x);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$w);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$x);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$w);
     // Check if the current agent matches the provided agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$x, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$w, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "commitAssistantMessage" skipped due to the agent change', {
@@ -16029,11 +16754,11 @@ const commitAssistantMessage = beginContext(async (content, clientId, agentName)
         return;
     }
     // Commit the assistant message via SessionPublicService
-    await swarm$1.sessionPublicService.commitAssistantMessage(content, METHOD_NAME$x, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitAssistantMessage(content, METHOD_NAME$w, clientId, swarmName);
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$w = "function.commit.commitAssistantMessageForce";
+const METHOD_NAME$v = "function.commit.commitAssistantMessageForce";
 /**
  * Forcefully commits an assistant-generated message to a session in the swarm system, without checking the active agent.
  * Validates the session and swarm, then proceeds with committing the message regardless of the current agent state.
@@ -16052,21 +16777,21 @@ const METHOD_NAME$w = "function.commit.commitAssistantMessageForce";
 const commitAssistantMessageForce = beginContext(async (content, clientId) => {
     // Log the commit attempt if enabled
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$w, {
+        swarm$1.loggerService.log(METHOD_NAME$v, {
             content,
             clientId,
         });
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$w);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$v);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$w);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$v);
     // Commit the assistant message via SessionPublicService without agent checks
-    await swarm$1.sessionPublicService.commitAssistantMessage(content, METHOD_NAME$w, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitAssistantMessage(content, METHOD_NAME$v, clientId, swarmName);
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$v = "function.commit.cancelOutput";
+const METHOD_NAME$u = "function.commit.cancelOutput";
 /**
  * Cancels the awaited output for a specific client and agent by emitting an empty string.
  * Validates the agent, session, and swarm, ensuring the current agent matches the provided agent before cancellation.
@@ -16082,19 +16807,19 @@ const METHOD_NAME$v = "function.commit.cancelOutput";
 const cancelOutput = beginContext(async (clientId, agentName) => {
     // Log the cancellation attempt if enabled
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$v, {
+        swarm$1.loggerService.log(METHOD_NAME$u, {
             clientId,
             agentName,
         });
     // Validate the agent exists
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$v);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$u);
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$v);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$u);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$v);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$u);
     // Check if the current agent matches the provided agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$v, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$u, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "cancelOutput" skipped due to the agent change', {
@@ -16105,11 +16830,11 @@ const cancelOutput = beginContext(async (clientId, agentName) => {
         return;
     }
     // Perform the output cancellation via SwarmPublicService
-    await swarm$1.swarmPublicService.cancelOutput(METHOD_NAME$v, clientId, swarmName);
+    await swarm$1.swarmPublicService.cancelOutput(METHOD_NAME$u, clientId, swarmName);
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$u = "function.commit.cancelOutputForce";
+const METHOD_NAME$t = "function.commit.cancelOutputForce";
 /**
  * Forcefully cancels the awaited output for a specific client by emitting an empty string, without checking the active agent.
  * Validates the session and swarm, then proceeds with cancellation regardless of the current agent state.
@@ -16126,20 +16851,20 @@ const METHOD_NAME$u = "function.commit.cancelOutputForce";
 const cancelOutputForce = beginContext(async (clientId) => {
     // Log the cancellation attempt if enabled
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$u, {
+        swarm$1.loggerService.log(METHOD_NAME$t, {
             clientId,
         });
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$u);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$t);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$u);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$t);
     // Perform the output cancellation via SwarmPublicService without agent checks
-    await swarm$1.swarmPublicService.cancelOutput(METHOD_NAME$u, clientId, swarmName);
+    await swarm$1.swarmPublicService.cancelOutput(METHOD_NAME$t, clientId, swarmName);
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$t = "function.commit.commitStopTools";
+const METHOD_NAME$s = "function.commit.commitStopTools";
 /**
  * Prevents the next tool from being executed for a specific client and agent in the swarm system.
  * Validates the agent, session, and swarm, ensuring the current agent matches the provided agent before stopping tool execution.
@@ -16156,19 +16881,19 @@ const METHOD_NAME$t = "function.commit.commitStopTools";
 const commitStopTools = beginContext(async (clientId, agentName) => {
     // Log the stop tools attempt if enabled
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$t, {
+        swarm$1.loggerService.log(METHOD_NAME$s, {
             clientId,
             agentName,
         });
     // Validate the agent exists
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$t);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$s);
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$t);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$s);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$t);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$s);
     // Check if the current agent matches the provided agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$t, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$s, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "commitStopTools" skipped due to the agent change', {
@@ -16179,11 +16904,11 @@ const commitStopTools = beginContext(async (clientId, agentName) => {
         return;
     }
     // Commit the stop of the next tool execution via SessionPublicService
-    await swarm$1.sessionPublicService.commitStopTools(METHOD_NAME$t, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitStopTools(METHOD_NAME$s, clientId, swarmName);
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$s = "function.commit.commitStopToolsForce";
+const METHOD_NAME$r = "function.commit.commitStopToolsForce";
 /**
  * Forcefully prevents the next tool from being executed for a specific client in the swarm system, without checking the active agent.
  * Validates the session and swarm, then proceeds with stopping tool execution regardless of the current agent state.
@@ -16201,21 +16926,21 @@ const METHOD_NAME$s = "function.commit.commitStopToolsForce";
 const commitStopToolsForce = beginContext(async (clientId) => {
     // Log the stop tools attempt if enabled
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$s, {
+        swarm$1.loggerService.log(METHOD_NAME$r, {
             clientId,
-            METHOD_NAME: METHOD_NAME$s,
+            METHOD_NAME: METHOD_NAME$r,
         });
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$s);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$r);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$s);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$r);
     // Commit the stop of the next tool execution via SessionPublicService without agent checks
-    await swarm$1.sessionPublicService.commitStopTools(METHOD_NAME$s, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitStopTools(METHOD_NAME$r, clientId, swarmName);
 });
 
 /** @constant {string} METHOD_NAME - The name of the method used for logging and validation */
-const METHOD_NAME$r = "function.target.question";
+const METHOD_NAME$q = "function.target.question";
 /**
  * Initiates a question process within a chat context
  * @function question
@@ -16227,21 +16952,21 @@ const METHOD_NAME$r = "function.target.question";
  */
 const question = beginContext(async (message, clientId, agentName, wikiName) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$r, {
+        swarm$1.loggerService.log(METHOD_NAME$q, {
             message,
             clientId,
             agentName,
             wikiName,
         });
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$r);
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$r);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$q);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$q);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$r);
-    swarm$1.wikiValidationService.validate(wikiName, METHOD_NAME$r);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$q);
+    swarm$1.wikiValidationService.validate(wikiName, METHOD_NAME$q);
     if (!swarm$1.agentValidationService.hasWiki(agentName, wikiName)) {
-        throw new Error(`agent-swarm ${METHOD_NAME$r} ${wikiName} not registered in ${agentName}`);
+        throw new Error(`agent-swarm ${METHOD_NAME$q} ${wikiName} not registered in ${agentName}`);
     }
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$r, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$q, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "question" skipped due to the agent change', {
@@ -16264,7 +16989,7 @@ const question = beginContext(async (message, clientId, agentName, wikiName) =>
 });
 
 /** @constant {string} METHOD_NAME - The name of the method used for logging and validation */
-const METHOD_NAME$q = "function.target.questionForce";
+const METHOD_NAME$p = "function.target.questionForce";
 /**
  * Initiates a forced question process within a chat context
  * @function questionForce
@@ -16275,17 +17000,17 @@ const METHOD_NAME$q = "function.target.questionForce";
  */
 const questionForce = beginContext(async (message, clientId, wikiName) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$q, {
+        swarm$1.loggerService.log(METHOD_NAME$p, {
             message,
             clientId,
             wikiName,
         });
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$q);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$p);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$q);
-    swarm$1.wikiValidationService.validate(wikiName, METHOD_NAME$q);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$p);
+    swarm$1.wikiValidationService.validate(wikiName, METHOD_NAME$p);
     const { getChat, callbacks } = swarm$1.wikiSchemaService.get(wikiName);
-    const agentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$q, clientId, swarmName);
+    const agentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$p, clientId, swarmName);
     const args = {
         clientId,
         message,
@@ -16297,7 +17022,7 @@ const questionForce = beginContext(async (message, clientId, wikiName) => {
     return await getChat(args);
 });
 
-const METHOD_NAME$p = "function.target.disposeConnection";
+const METHOD_NAME$o = "function.target.disposeConnection";
 /**
  * Disposes of a client session and all related resources within a swarm.
  *
@@ -16314,10 +17039,10 @@ const METHOD_NAME$p = "function.target.disposeConnection";
  * @example
  * await disposeConnection("client-123", "TaskSwarm");
  */
-const disposeConnection = beginContext(async (clientId, swarmName, methodName = METHOD_NAME$p) => {
+const disposeConnection = beginContext(async (clientId, swarmName, methodName = METHOD_NAME$o) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$p, {
+        swarm$1.loggerService.log(METHOD_NAME$o, {
             clientId,
             swarmName,
         });
@@ -16389,7 +17114,7 @@ const disposeConnection = beginContext(async (clientId, swarmName, methodName =
     PersistMemoryAdapter.dispose(clientId);
 });
 
-const METHOD_NAME$o = "function.target.makeAutoDispose";
+const METHOD_NAME$n = "function.target.makeAutoDispose";
 /**
  * Default timeout in seconds before auto-dispose is triggered.
  * @constant {number}
@@ -16420,7 +17145,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$o, {
+        swarm$1.loggerService.log(METHOD_NAME$n, {
             clientId,
             swarmName,
         });
@@ -16453,7 +17178,7 @@ const makeAutoDispose = beginContext((clientId, swarmName, { timeoutSeconds = DE
     };
 });
 
-const METHOD_NAME$n = "function.target.execute";
+const METHOD_NAME$m = "function.target.execute";
 /**
  * Sends a message to the active agent in a swarm session as if it originated from the client side.
  *
@@ -16475,19 +17200,19 @@ const execute = beginContext(async (content, clientId, agentName) => {
     const executionId = functoolsKit.randomString();
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$n, {
+        swarm$1.loggerService.log(METHOD_NAME$m, {
             content,
             clientId,
             agentName,
             executionId,
         });
     // Validate the agent, session, and swarm
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$n);
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$n);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$m);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$m);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$n);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$m);
     // Check if the specified agent is still the active agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$n, 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 "execute" skipped due to the agent change', {
@@ -16506,7 +17231,7 @@ const execute = beginContext(async (content, clientId, agentName) => {
                 agentName,
                 swarmName,
             });
-            const result = await swarm$1.sessionPublicService.execute(content, "tool", METHOD_NAME$n, clientId, swarmName);
+            const result = await swarm$1.sessionPublicService.execute(content, "tool", METHOD_NAME$m, clientId, swarmName);
             isFinished = swarm$1.perfService.endExecution(executionId, clientId, result.length);
             swarm$1.busService.commitExecutionEnd(clientId, {
                 agentName,
@@ -16526,7 +17251,7 @@ const execute = beginContext(async (content, clientId, agentName) => {
     });
 });
 
-const METHOD_NAME$m = "function.target.emit";
+const METHOD_NAME$l = "function.target.emit";
 /**
  * Emits a string as model output without executing an incoming message, with agent activity validation.
  *
@@ -16546,18 +17271,18 @@ const METHOD_NAME$m = "function.target.emit";
 const emit = beginContext(async (content, clientId, agentName) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$m, {
+        swarm$1.loggerService.log(METHOD_NAME$l, {
             content,
             clientId,
             agentName,
         });
     // Validate the agent, session, and swarm
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$m);
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$m);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$l);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$l);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$m);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$l);
     // Check if the specified agent is still the active agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$m, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$l, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "emit" skipped due to the agent change', {
@@ -16568,10 +17293,10 @@ const emit = beginContext(async (content, clientId, agentName) => {
         return;
     }
     // Emit the content directly via the session public service
-    return await swarm$1.sessionPublicService.emit(content, METHOD_NAME$m, clientId, swarmName);
+    return await swarm$1.sessionPublicService.emit(content, METHOD_NAME$l, clientId, swarmName);
 });
 
-const METHOD_NAME$l = "function.target.notify";
+const METHOD_NAME$k = "function.target.notify";
 /**
  * Sends a notification message as output from the swarm session without executing an incoming message.
  *
@@ -16591,23 +17316,23 @@ const METHOD_NAME$l = "function.target.notify";
 const notify = beginContext(async (content, clientId, agentName) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$l, {
+        swarm$1.loggerService.log(METHOD_NAME$k, {
             content,
             clientId,
             agentName,
         });
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$l);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$k);
     // 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$l);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$k);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$l);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$k);
     // Check if the specified agent is still the active agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$l, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$k, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "notify" skipped due to the agent change', {
@@ -16618,10 +17343,10 @@ const notify = beginContext(async (content, clientId, agentName) => {
         return;
     }
     // Notify the content directly via the session public service
-    return await swarm$1.sessionPublicService.notify(content, METHOD_NAME$l, clientId, swarmName);
+    return await swarm$1.sessionPublicService.notify(content, METHOD_NAME$k, clientId, swarmName);
 });
 
-const METHOD_NAME$k = "function.target.notifyForce";
+const METHOD_NAME$j = "function.target.notifyForce";
 /**
  * Sends a notification message as output from the swarm session without executing an incoming message.
  *
@@ -16640,11 +17365,11 @@ const METHOD_NAME$k = "function.target.notifyForce";
 const notifyForce = 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$k, {
+        swarm$1.loggerService.log(METHOD_NAME$j, {
             content,
             clientId,
         });
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$k);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$j);
     // Check if the session mode is "makeConnection"
     if (swarm$1.sessionValidationService.getSessionMode(clientId) !==
         "makeConnection") {
@@ -16652,12 +17377,12 @@ const notifyForce = beginContext(async (content, clientId) => {
     }
     // Validate the agent, session, and swarm
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$k);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$j);
     // Notify the content directly via the session public service
-    return await swarm$1.sessionPublicService.notify(content, METHOD_NAME$k, clientId, swarmName);
+    return await swarm$1.sessionPublicService.notify(content, METHOD_NAME$j, clientId, swarmName);
 });
 
-const METHOD_NAME$j = "function.target.runStateless";
+const METHOD_NAME$i = "function.target.runStateless";
 /**
  * Executes a message statelessly with an agent in a swarm session, bypassing chat history.
  *
@@ -16680,19 +17405,19 @@ const runStateless = beginContext(async (content, clientId, agentName) => {
     const executionId = functoolsKit.randomString();
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$j, {
+        swarm$1.loggerService.log(METHOD_NAME$i, {
             content,
             clientId,
             agentName,
             executionId,
         });
     // Validate the agent, session, and swarm
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$j);
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$j);
+    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$j);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$i);
     // Check if the specified agent is still the active agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$j, clientId, swarmName);
+    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 "runStateless" skipped due to the agent change', {
@@ -16711,7 +17436,7 @@ const runStateless = beginContext(async (content, clientId, agentName) => {
                 agentName,
                 swarmName,
             });
-            const result = await swarm$1.sessionPublicService.run(content, METHOD_NAME$j, clientId, swarmName);
+            const result = await swarm$1.sessionPublicService.run(content, METHOD_NAME$i, clientId, swarmName);
             isFinished = swarm$1.perfService.endExecution(executionId, clientId, result.length);
             swarm$1.busService.commitExecutionEnd(clientId, {
                 agentName,
@@ -16731,7 +17456,7 @@ const runStateless = beginContext(async (content, clientId, agentName) => {
     });
 });
 
-const METHOD_NAME$i = "function.target.runStatelessForce";
+const METHOD_NAME$h = "function.target.runStatelessForce";
 /**
  * Executes a message statelessly with the active agent in a swarm session, bypassing chat history and forcing execution regardless of agent activity.
  *
@@ -16752,22 +17477,22 @@ const runStatelessForce = beginContext(async (content, clientId) => {
     const executionId = functoolsKit.randomString();
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$i, {
+        swarm$1.loggerService.log(METHOD_NAME$h, {
             content,
             clientId,
             executionId,
         });
     // Validate the session and swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$i);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$h);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$i);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$h);
     // 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$i, clientId, swarmName);
+            const result = await swarm$1.sessionPublicService.run(content, METHOD_NAME$h, clientId, swarmName);
             isFinished = swarm$1.perfService.endExecution(executionId, clientId, result.length);
             swarm$1.busService.commitExecutionEnd(clientId, { swarmName });
             return result;
@@ -16794,7 +17519,7 @@ const SCHEDULED_DELAY$1 = 1000;
  * @constant {number}
  */
 const RATE_DELAY = 10000;
-const METHOD_NAME$h = "function.target.makeConnection";
+const METHOD_NAME$g = "function.target.makeConnection";
 /**
  * Internal implementation of the connection factory for a client to a swarm.
  *
@@ -16809,21 +17534,21 @@ const METHOD_NAME$h = "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$h, {
+        swarm$1.loggerService.log(METHOD_NAME$g, {
             clientId,
             swarmName,
         });
     // Validate the swarm and initialize the session
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$h);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$g);
     swarm$1.sessionValidationService.addSession(clientId, swarmName, "makeConnection");
     // Create a queued send function using the session public service
-    const send = functoolsKit.queued(swarm$1.sessionPublicService.connect(connector, METHOD_NAME$h, clientId, swarmName));
+    const send = functoolsKit.queued(swarm$1.sessionPublicService.connect(connector, METHOD_NAME$g, clientId, swarmName));
     // Return a wrapped send function with validation and agent context
     return (async (outgoing) => {
-        swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$h);
+        swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$g);
         return await send({
             data: outgoing,
-            agentName: await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$h, clientId, swarmName),
+            agentName: await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$g, clientId, swarmName),
             clientId,
         });
     });
@@ -16906,13 +17631,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$h, clientId, swarmName);
+                    await swarm$1.sessionPublicService.commitUserMessage(content, "user", METHOD_NAME$g, clientId, swarmName);
                 }, {
                     clientId,
                     payload,
                 });
             }
-            await swarm$1.sessionPublicService.commitUserMessage(content, "user", METHOD_NAME$h, clientId, swarmName);
+            await swarm$1.sessionPublicService.commitUserMessage(content, "user", METHOD_NAME$g, clientId, swarmName);
         }),
         delay,
     });
@@ -16975,7 +17700,7 @@ makeConnection.rate = (connector, clientId, swarmName, { delay = RATE_DELAY } =
     };
 };
 
-const METHOD_NAME$g = "function.target.complete";
+const METHOD_NAME$f = "function.target.complete";
 /**
  * Time-to-live for the complete function in milliseconds.
  * Defines how long the cached complete function remains valid before expiring.
@@ -17017,7 +17742,7 @@ const createComplete = functoolsKit.ttl((clientId, swarmName) => functoolsKit.qu
  *
  * @returns {Promise<void>} A promise that resolves when the garbage collector is initialized.
  */
-const createGc$2 = functoolsKit.singleshot(async () => {
+const createGc$1 = functoolsKit.singleshot(async () => {
     setInterval(createComplete.gc, COMPLETE_GC);
 });
 /**
@@ -17041,7 +17766,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$g, {
+        swarm$1.loggerService.log(METHOD_NAME$f, {
             content,
             clientId,
             executionId,
@@ -17050,7 +17775,7 @@ const complete = beginContext(async (content, clientId, swarmName, payload = nul
     await markOnline(clientId, swarmName);
     // Set up the TTL-limited, queued execution function and garbage collector
     const run = await createComplete(clientId, swarmName);
-    createGc$2();
+    createGc$1();
     // Execute the command within an execution context with performance tracking
     const handleRun = async () => {
         return await ExecutionContextService.runInContext(async () => {
@@ -17059,7 +17784,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$g, content);
+                const result = await run(METHOD_NAME$f, content);
                 isFinished = swarm$1.perfService.endExecution(executionId, clientId, result.length);
                 swarm$1.busService.commitExecutionEnd(clientId, { swarmName });
                 return result;
@@ -17089,7 +17814,7 @@ const complete = beginContext(async (content, clientId, swarmName, payload = nul
  * @constant {number}
  */
 const SCHEDULED_DELAY = 1000;
-const METHOD_NAME$f = "function.target.session";
+const METHOD_NAME$e = "function.target.session";
 /**
  * Internal implementation of the session factory for a client and swarm.
  *
@@ -17104,23 +17829,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$f, {
+        swarm$1.loggerService.log(METHOD_NAME$e, {
             clientId,
             swarmName,
             executionId,
         });
     // Validate the swarm and initialize the session
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$f);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$e);
     swarm$1.sessionValidationService.addSession(clientId, swarmName, "session");
     const complete = functoolsKit.queued(async (content) => {
-        swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$f);
+        swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$e);
         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$f, clientId, swarmName);
+                const result = await swarm$1.sessionPublicService.execute(content, "user", METHOD_NAME$e, clientId, swarmName);
                 isFinished = swarm$1.perfService.endExecution(executionId, clientId, result.length);
                 swarm$1.busService.commitExecutionEnd(clientId, { swarmName });
                 return result;
@@ -17141,7 +17866,7 @@ const sessionInternal = (clientId, swarmName, { onDispose = () => { } } = {}) =>
             return await complete(content);
         }),
         dispose: async () => {
-            await disposeConnection(clientId, swarmName, METHOD_NAME$f);
+            await disposeConnection(clientId, swarmName, METHOD_NAME$e);
             await onDispose();
         },
     };
@@ -17241,13 +17966,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$f, clientId, swarmName);
+                    return await swarm$1.sessionPublicService.commitUserMessage(content, "user", METHOD_NAME$e, clientId, swarmName);
                 }, {
                     clientId,
                     payload,
                 });
             }
-            return await swarm$1.sessionPublicService.commitUserMessage(content, "user", METHOD_NAME$f, clientId, swarmName);
+            return await swarm$1.sessionPublicService.commitUserMessage(content, "user", METHOD_NAME$e, clientId, swarmName);
         }),
         delay,
     });
@@ -17327,7 +18052,7 @@ session.rate = (clientId, swarmName, { delay = SCHEDULED_DELAY, onDispose } = {}
 };
 
 /** @private Constant defining the method name for logging purposes */
-const METHOD_NAME$e = "function.common.hasSession";
+const METHOD_NAME$d = "function.common.hasSession";
 /**
  * Checks if a session exists for the given client ID.
  *
@@ -17339,11 +18064,11 @@ const METHOD_NAME$e = "function.common.hasSession";
  */
 const hasSession = (clientId) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$e, { clientId });
+        swarm$1.loggerService.log(METHOD_NAME$d, { clientId });
     return swarm$1.sessionValidationService.hasSession(clientId);
 };
 
-const METHOD_NAME$d = "function.common.getAgentName";
+const METHOD_NAME$c = "function.common.getAgentName";
 /**
  * Retrieves the name of the active agent for a given client session in a swarm.
  *
@@ -17361,18 +18086,18 @@ const METHOD_NAME$d = "function.common.getAgentName";
 const getAgentName = beginContext(async (clientId) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$d, {
+        swarm$1.loggerService.log(METHOD_NAME$c, {
             clientId,
         });
     // Validate the session and swarm to ensure they exist and are accessible
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$d);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$c);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$d);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$c);
     // Retrieve the active agent name via the swarm public service
-    return await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$d, clientId, swarmName);
+    return await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$c, clientId, swarmName);
 });
 
-const METHOD_NAME$c = "function.common.getAgentHistory";
+const METHOD_NAME$b = "function.common.getAgentHistory";
 /**
  * Retrieves the history prepared for a specific agent, incorporating rescue algorithm tweaks.
  *
@@ -17391,22 +18116,22 @@ const METHOD_NAME$c = "function.common.getAgentHistory";
 const getAgentHistory = 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$c, {
+        swarm$1.loggerService.log(METHOD_NAME$b, {
             clientId,
             agentName,
         });
     // Validate the session and agent to ensure they exist and are accessible
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$c);
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$c);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$b);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$b);
     // Retrieve the agent's prompt configuration from the agent schema service
     const { prompt } = swarm$1.agentSchemaService.get(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$c, clientId, agentName);
+    const history = await swarm$1.historyPublicService.toArrayForAgent(prompt, METHOD_NAME$b, clientId, agentName);
     // Return a shallow copy of the history array
     return [...history];
 });
 
-const METHOD_NAME$b = "function.common.getSessionMode";
+const METHOD_NAME$a = "function.common.getSessionMode";
 /**
  * Retrieves the session mode for a given client session in a swarm.
  *
@@ -17424,18 +18149,18 @@ const METHOD_NAME$b = "function.common.getSessionMode";
 const getSessionMode = 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$b, {
+        swarm$1.loggerService.log(METHOD_NAME$a, {
             clientId,
         });
     // Validate the session and swarm to ensure they exist and are accessible
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$b);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$a);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$b);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$a);
     // Retrieve the session mode from the session validation service
     return swarm$1.sessionValidationService.getSessionMode(clientId);
 });
 
-const METHOD_NAME$a = "function.common.getSessionContext";
+const METHOD_NAME$9 = "function.common.getSessionContext";
 /**
  * Retrieves the session context for the current execution environment.
  *
@@ -17452,7 +18177,7 @@ const METHOD_NAME$a = "function.common.getSessionContext";
 const getSessionContext = async () => {
     // Log the operation 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$9);
     // Determine the method context, if active
     const methodContext = MethodContextService.hasContext()
         ? swarm$1.methodContextService.context
@@ -17476,7 +18201,7 @@ const getSessionContext = async () => {
  * @private Constant defining the method name for logging purposes.
  * Used as an identifier in log messages to track calls to `getNavigationRoute`.
  */
-const METHOD_NAME$9 = "function.common.getNavigationRoute";
+const METHOD_NAME$8 = "function.common.getNavigationRoute";
 /**
  * Retrieves the navigation route for a given client and swarm.
  * Delegates to `NavigationValidationService.getNavigationRoute` to obtain a `Set` of visited agent names,
@@ -17487,15 +18212,15 @@ const METHOD_NAME$9 = "function.common.getNavigationRoute";
  */
 const getNavigationRoute = (clientId, swarmName) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$9, {
+        swarm$1.loggerService.log(METHOD_NAME$8, {
             clientId,
             swarmName,
         });
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$9);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$8);
     return swarm$1.navigationValidationService.getNavigationRoute(clientId, swarmName);
 };
 
-const METHOD_NAME$8 = "function.history.getUserHistory";
+const METHOD_NAME$7 = "function.history.getUserHistory";
 /**
  * Retrieves the user-specific history entries for a given client session.
  *
@@ -17513,15 +18238,15 @@ const METHOD_NAME$8 = "function.history.getUserHistory";
 const getUserHistory = 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$8, {
+        swarm$1.loggerService.log(METHOD_NAME$7, {
             clientId,
         });
     // Fetch raw history and filter for user role and mode
-    const history = await getRawHistory(clientId, METHOD_NAME$8);
+    const history = await getRawHistory(clientId, METHOD_NAME$7);
     return history.filter(({ role, mode }) => role === "user" && mode === "user");
 });
 
-const METHOD_NAME$7 = "function.history.getAssistantHistory";
+const METHOD_NAME$6 = "function.history.getAssistantHistory";
 /**
  * Retrieves the assistant's history entries for a given client session.
  *
@@ -17539,15 +18264,15 @@ const METHOD_NAME$7 = "function.history.getAssistantHistory";
 const getAssistantHistory = 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$7, {
+        swarm$1.loggerService.log(METHOD_NAME$6, {
             clientId,
         });
     // Fetch raw history and filter for assistant role
-    const history = await getRawHistory(clientId, METHOD_NAME$7);
+    const history = await getRawHistory(clientId, METHOD_NAME$6);
     return history.filter(({ role }) => role === "assistant");
 });
 
-const METHOD_NAME$6 = "function.history.getLastAssistantMessage";
+const METHOD_NAME$5 = "function.history.getLastAssistantMessage";
 /**
  * Retrieves the content of the most recent assistant message from a client's session history.
  *
@@ -17565,16 +18290,16 @@ const METHOD_NAME$6 = "function.history.getLastAssistantMessage";
 const getLastAssistantMessage = 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$6, {
+        swarm$1.loggerService.log(METHOD_NAME$5, {
             clientId,
         });
     // Fetch raw history and find the last assistant message
-    const history = await getRawHistory(clientId, METHOD_NAME$6);
+    const history = await getRawHistory(clientId, METHOD_NAME$5);
     const last = history.findLast(({ role }) => role === "assistant");
     return last ? last.content : null;
 });
 
-const METHOD_NAME$5 = "function.history.getLastSystemMessage";
+const METHOD_NAME$4 = "function.history.getLastSystemMessage";
 /**
  * Retrieves the content of the most recent system message from a client's session history.
  *
@@ -17592,16 +18317,16 @@ const METHOD_NAME$5 = "function.history.getLastSystemMessage";
 const getLastSystemMessage = 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$5, {
+        swarm$1.loggerService.log(METHOD_NAME$4, {
             clientId,
         });
     // Fetch raw history and find the last system message
-    const history = await getRawHistory(clientId, METHOD_NAME$5);
+    const history = await getRawHistory(clientId, METHOD_NAME$4);
     const last = history.findLast(({ role }) => role === "system");
     return last ? last.content : null;
 });
 
-const METHOD_NAME$4 = "function.event.listenEvent";
+const METHOD_NAME$3 = "function.event.listenEvent";
 /**
  * Set of reserved event source names that cannot be used for custom events.
  * @constant {Set<EventSource>}
@@ -17637,7 +18362,7 @@ const DISALLOWED_EVENT_SOURCE_LIST$2 = new Set([
 const event = beginContext((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$4, {
+        swarm$1.loggerService.log(METHOD_NAME$3, {
             clientId,
         });
     // Check if the topic name is reserved
@@ -17652,7 +18377,7 @@ const event = beginContext((clientId, topicName, payload) => {
     });
 });
 
-const METHOD_NAME$3 = "function.event.listenEvent";
+const METHOD_NAME$2 = "function.event.listenEvent";
 /**
  * Set of reserved event source names that cannot be used for custom event topics.
  * @constant {Set<EventSource>}
@@ -17704,7 +18429,7 @@ const validateClientId$g = (clientId) => {
 const listenEvent = 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$3, {
+        swarm$1.loggerService.log(METHOD_NAME$2, {
             clientId,
         });
     // Check if the topic name is reserved
@@ -17717,7 +18442,7 @@ const listenEvent = beginContext((clientId, topicName, fn) => {
     return swarm$1.busService.subscribe(clientId, topicName, functoolsKit.queued(async ({ payload }) => await fn(payload)));
 });
 
-const METHOD_NAME$2 = "function.event.listenEventOnce";
+const METHOD_NAME$1 = "function.event.listenEventOnce";
 /**
  * Set of reserved event source names that cannot be used for custom event topics.
  * @constant {Set<EventSource>}
@@ -17775,7 +18500,7 @@ const validateClientId$f = (clientId) => {
 const listenEventOnce = 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$2, {
+        swarm$1.loggerService.log(METHOD_NAME$1, {
             clientId,
         });
     // Check if the topic name is reserved
@@ -17788,112 +18513,6 @@ const listenEventOnce = beginContext((clientId, topicName, filterFn, fn) => {
     return swarm$1.busService.once(clientId, topicName, ({ payload }) => filterFn(payload), functoolsKit.queued(async ({ payload }) => await fn(payload)));
 });
 
-const METHOD_NAME$1 = "function.navigate.changeToAgent";
-/**
- * Time-to-live for the change agent function in milliseconds.
- * Defines how long the cached change agent function remains valid before expiring.
- * @constant {number}
- */
-const CHANGE_AGENT_TTL$1 = 15 * 60 * 1000;
-/**
- * Garbage collection interval for the change agent function in milliseconds.
- * Specifies the frequency at which expired TTL entries are cleaned up.
- * @constant {number}
- */
-const CHANGE_AGENT_GC$1 = 60 * 1000;
-/**
- * Creates a change agent function with time-to-live (TTL) and queuing capabilities.
- *
- * This factory function generates a queued, TTL-limited function to handle agent changes for a specific client session,
- * ensuring operations are executed sequentially and cached results are reused within the TTL period.
- *
- * @function
- * @param {string} clientId - The unique identifier of the client session.
- * @returns {TChangeToAgentRun} A function that performs the agent change operation with queuing and TTL.
- */
-const createChangeToAgent = functoolsKit.ttl((clientId) => functoolsKit.queued(async (methodName, agentName, swarmName) => {
-    if (!swarm$1.navigationValidationService.shouldNavigate(agentName, clientId, swarmName)) {
-        console.warn(`function "changeToAgent" skipped due to the circular route found clientId=${clientId} swarmName=${swarmName} agentNameTo=${agentName}`);
-        return false;
-    }
-    // Notify all agents in the swarm of the change
-    await Promise.all(swarm$1.swarmValidationService
-        .getAgentList(swarmName)
-        .map(async (agentName) => {
-        await swarm$1.agentPublicService.commitAgentChange(methodName, clientId, agentName);
-    }));
-    {
-        // Dispose of the current agent's resources and set up the new agent
-        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));
-    }
-    // Set the new agent as the active agent
-    await swarm$1.swarmPublicService.setAgentName(agentName, methodName, clientId, swarmName);
-    return true;
-}), {
-    key: ([clientId]) => `${clientId}`,
-    timeout: CHANGE_AGENT_TTL$1,
-});
-/**
- * Creates a garbage collector for the change agent function.
- *
- * This function sets up a singleton interval-based garbage collector to periodically clean up expired TTL entries from `createChangeToAgent`.
- *
- * @function
- * @returns {Promise<void>} A promise that resolves when the garbage collector is initialized.
- */
-const createGc$1 = functoolsKit.singleshot(async () => {
-    setInterval(createChangeToAgent.gc, CHANGE_AGENT_GC$1);
-});
-/**
- * Changes the active agent for a given client session in a swarm.
- *
- * This function facilitates switching the active agent in a swarm session, validating the session and agent dependencies,
- * logging the operation if enabled, and executing the change using a TTL-limited, queued runner.
- * The execution is wrapped in `beginContext` to ensure it runs outside of existing method and execution contexts.
- *
- * @param {AgentName} agentName - The name of the agent to switch to.
- * @param {string} clientId - The unique identifier of the client session.
- * @returns {Promise<boolean>} A promise that resolves when the agent change is complete. If it resolved false, the navigation is canceled due to recursion
- * @throws {Error} If session or agent validation fails, or if the agent change process encounters an error.
- * @example
- * await changeToAgent("AgentX", "client-123");
- */
-const changeToAgent = beginContext(async (agentName, clientId) => {
-    // Log the operation details if logging is enabled in GLOBAL_CONFIG
-    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$1, {
-            agentName,
-            clientId,
-        });
-    const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    {
-        // Validate session, agent, and dependencies
-        swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1);
-        swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1);
-        const activeAgent = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1, clientId, swarmName);
-        if (!swarm$1.agentValidationService.hasDependency(activeAgent, agentName)) {
-            console.error(`agent-swarm missing dependency detected for activeAgent=${activeAgent} dependencyAgent=${agentName}`);
-        }
-    }
-    if (!swarm$1.swarmValidationService.getAgentSet(swarmName).has(agentName)) {
-        GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-            swarm$1.loggerService.log('function "changeToAgent" skipped due to the agent is not in the swarm', {
-                agentName,
-                clientId,
-                swarmName,
-            });
-        console.warn(`function "changeToAgent" skipped due to the agent is not in the swarm clientId=${clientId} agentName=${agentName} swarmName=${swarmName}`);
-        return false;
-    }
-    // Execute the agent change with TTL and queuing
-    const run = await createChangeToAgent(clientId);
-    createGc$1();
-    return await run(METHOD_NAME$1, agentName, swarmName);
-});
-
 const METHOD_NAME = "function.navigate.changeToPrevAgent";
 /**
  * Time-to-live for the change agent function in milliseconds.
@@ -20016,6 +20635,7 @@ exports.Utils = Utils;
 exports.addAgent = addAgent;
 exports.addCompletion = addCompletion;
 exports.addEmbedding = addEmbedding;
+exports.addMCP = addMCP;
 exports.addPolicy = addPolicy;
 exports.addState = addState;
 exports.addStorage = addStorage;
@@ -20041,6 +20661,7 @@ exports.commitToolOutputForce = commitToolOutputForce;
 exports.commitUserMessage = commitUserMessage;
 exports.commitUserMessageForce = commitUserMessageForce;
 exports.complete = complete;
+exports.createNavigateToAgent = createNavigateToAgent;
 exports.createNavigateToTriageAgent = createNavigateToTriageAgent;
 exports.disposeConnection = disposeConnection;
 exports.dumpAgent = dumpAgent;
@@ -20094,6 +20715,7 @@ exports.notifyForce = notifyForce;
 exports.overrideAgent = overrideAgent;
 exports.overrideCompletion = overrideCompletion;
 exports.overrideEmbeding = overrideEmbeding;
+exports.overrideMCP = overrideMCP;
 exports.overridePolicy = overridePolicy;
 exports.overrideState = overrideState;
 exports.overrideStorage = overrideStorage;