agent-swarm-kit 1.0.223 → 1.0.224

package/build/index.cjs

@@ -64,6 +64,7 @@ const schemaServices$1 = {
     stateSchemaService: Symbol('stateSchemaService'),
     memorySchemaService: Symbol('memorySchemaService'),
     policySchemaService: Symbol('policySchemaService'),
+    wikiSchemaService: Symbol('wikiSchemaService'),
 };
 const metaServices$1 = {
     agentMetaService: Symbol('agentMetaService'),
@@ -90,6 +91,7 @@ const validationServices$1 = {
     storageValidationService: Symbol('storageValidationService'),
     policyValidationService: Symbol('policyValidationService'),
     navigationValidationService: Symbol('navigationValidationService'),
+    wikiValidationService: Symbol('wikiValidationService'),
 };
 const TYPES = {
     ...baseServices$1,
@@ -3137,6 +3139,16 @@ class AgentSchemaService {
             if (agentSchema.storages?.some((value) => typeof value !== "string")) {
                 throw new Error(`agent-swarm agent schema validation failed: invalid storages for agentName=${agentSchema.agentName} storages=[${agentSchema.storages}]`);
             }
+            if (agentSchema.wikiList && !Array.isArray(agentSchema.wikiList)) {
+                throw new Error(`agent-swarm agent schema validation failed: invalid wikiList for agentName=${agentSchema.agentName} wikiList=${agentSchema.wikiList}`);
+            }
+            if (agentSchema.wikiList &&
+                agentSchema.wikiList.length !== new Set(agentSchema.wikiList).size) {
+                throw new Error(`agent-swarm agent schema validation failed: found duplicate wikiList for agentName=${agentSchema.agentName} wikiList=[${agentSchema.wikiList}]`);
+            }
+            if (agentSchema.wikiList?.some((value) => typeof value !== "string")) {
+                throw new Error(`agent-swarm agent schema validation failed: invalid wikiList for agentName=${agentSchema.agentName} wikiList=[${agentSchema.wikiList}]`);
+            }
             if (agentSchema.tools && !Array.isArray(agentSchema.tools)) {
                 throw new Error(`agent-swarm agent schema validation failed: invalid tools for agentName=${agentSchema.agentName} tools=${agentSchema.tools}`);
             }
@@ -4307,7 +4319,7 @@ class AgentConnectionService {
 }
 
 /** @private Constant defining the method name for logging purposes */
-const METHOD_NAME$Z = "function.common.getPayload";
+const METHOD_NAME$10 = "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.
@@ -4318,7 +4330,7 @@ const METHOD_NAME$Z = "function.common.getPayload";
  * console.log(payload); // { id: number } or null
  */
 const getPayload = () => {
-    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$Z);
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$10);
     if (PayloadContextService.hasContext()) {
         const { payload } = swarm$1.payloadContextService.context;
         return payload;
@@ -7618,6 +7630,14 @@ class AgentValidationService {
          * @readonly
          */
         this.toolValidationService = inject(TYPES.toolValidationService);
+        /**
+         * Wiki validation service instance for validating wikies associated with agents.
+         * Injected via DI, used in validate method to check agent wiki list.
+         * @type {WikiValidationService}
+         * @private
+         * @readonly
+         */
+        this.wikiValidationService = inject(TYPES.wikiValidationService);
         /**
          * Completion validation service instance for validating completion configurations of agents.
          * Injected via DI, used in validate method to check agent completion.
@@ -7675,6 +7695,22 @@ class AgentValidationService {
             }
             return this._agentMap.get(agentName).storages || [];
         };
+        /**
+         * Retrieves the list of wiki names associated with a given agent.
+         * @param {AgentName} agentName - The name of the agent to query, sourced from Agent.interface.
+         * @returns {WikiName[]} An array of wikies names from the agent’s schema.
+         * @throws {Error} If the agent is not found in _agentMap.
+         */
+        this.getWikiList = (agentName) => {
+            GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO &&
+                this.loggerService.info("agentValidationService getWikiList", {
+                    agentName,
+                });
+            if (!this._agentMap.has(agentName)) {
+                throw new Error(`agent-swarm agent ${agentName} not exist (getWikiList)`);
+            }
+            return this._agentMap.get(agentName).wikiList || [];
+        };
         /**
          * Retrieves the list of state names associated with a given agent.
          * Logs the operation and validates agent existence, supporting ClientState integration.
@@ -7733,6 +7769,25 @@ class AgentValidationService {
             const { storages = [] } = this._agentMap.get(agentName);
             return storages.includes(storageName);
         });
+        /**
+         * Checks if an agent has declared wiki
+         * @param {AgentName} agentName - The name of the agent to check, sourced from Agent.interface.
+         * @param {WikiName} wikiName - The name of the wiki to verify, sourced from Wiki.interface.
+         * @returns {boolean} True if the wiki is registered in the agent’s schema, false otherwise.
+         * @throws {Error} If the agent is not found in _agentMap.
+         */
+        this.hasWiki = functoolsKit.memoize(([agentName, wikiName]) => `${agentName}-${wikiName}`, (agentName, wikiName) => {
+            GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO &&
+                this.loggerService.info("agentValidationService hasWiki", {
+                    agentName,
+                    wikiName,
+                });
+            if (!this._agentMap.has(agentName)) {
+                throw new Error(`agent-swarm agent ${agentName} not exist (hasWiki)`);
+            }
+            const { wikiList = [] } = this._agentMap.get(agentName);
+            return wikiList.includes(wikiName);
+        });
         /**
          * Checks if an agent has a registered dependency on another agent, memoized for performance.
          * Logs the operation, supporting inter-agent dependency validation within SwarmSchemaService.
@@ -7802,6 +7857,12 @@ class AgentValidationService {
                 }
                 this.storageValidationService.validate(storageName, source);
             });
+            agent.wikiList?.forEach((wikiName) => {
+                if (typeof wikiName !== "string") {
+                    throw new Error(`agent-swarm agent ${agentName} storage list is invalid (wikiName=${String(wikiName)}) source=${source}`);
+                }
+                this.wikiValidationService.validate(wikiName, source);
+            });
         });
     }
 }
@@ -10751,6 +10812,13 @@ class DocService {
          * @private
          */
         this.storageSchemaService = inject(TYPES.storageSchemaService);
+        /**
+         * Wiki schema service instance, injected via DI.
+         * Supplies wiki details for writeAgentDoc, documenting wiki resources used by agents.
+         * @type {WikiSchemaService}
+         * @private
+         */
+        this.wikiSchemaService = inject(TYPES.wikiSchemaService);
         /**
          * State schema service instance, injected via DI.
          * Provides state details for writeAgentDoc, documenting state resources used by agents.
@@ -11085,6 +11153,33 @@ class DocService {
                     result.push("");
                 }
             }
+            if (agentSchema.wikiList) {
+                result.push(`## Used wiki list`);
+                result.push("");
+                for (let i = 0; i !== agentSchema.wikiList.length; i++) {
+                    if (!agentSchema.wikiList[i]) {
+                        continue;
+                    }
+                    result.push(`### ${i + 1}. ${agentSchema.wikiList[i]}`);
+                    const { docDescription, callbacks } = this.wikiSchemaService.get(agentSchema.wikiList[i]);
+                    if (docDescription) {
+                        result.push("");
+                        result.push(`#### Wiki description`);
+                        result.push("");
+                        result.push(docDescription);
+                    }
+                    if (callbacks) {
+                        result.push("");
+                        result.push(`#### Wiki callbacks`);
+                        result.push("");
+                        const callbackList = Object.keys(callbacks);
+                        for (let i = 0; i !== callbackList.length; i++) {
+                            result.push(`${i + 1}. \`${callbackList[i]}\``);
+                        }
+                    }
+                    result.push("");
+                }
+            }
             if (agentSchema.callbacks) {
                 result.push(`## Used callbacks`);
                 result.push("");
@@ -13322,6 +13417,123 @@ class NavigationValidationService {
     }
 }
 
+/**
+ * @class WikiSchemaService
+ * @description Service for managing wiki schema registrations and retrieval
+ */
+class WikiSchemaService {
+    constructor() {
+        /**
+         * @readonly
+         * @description Injected logger service instance
+         */
+        this.loggerService = inject(TYPES.loggerService);
+        /**
+         * @private
+         * @description Registry for storing wiki schemas
+         */
+        this.registry = new functoolsKit.ToolRegistry("wikiSchemaService");
+        /**
+         * Validates basic requirements of a wiki schema
+         * @private
+         * @param {IWikiSchema} wikiSchema - The wiki schema to validate
+         * @throws {Error} If validation fails
+         */
+        this.validateShallow = (wikiSchema) => {
+            GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO &&
+                this.loggerService.info(`wikiSchemaService validateShallow`, {
+                    wikiSchema,
+                });
+            if (typeof wikiSchema.wikiName !== "string") {
+                throw new Error(`agent-swarm wiki schema validation failed: missing wikiName`);
+            }
+            if (typeof wikiSchema.getChat !== "function") {
+                throw new Error(`agent-swarm wiki schema validation failed: missing getChat for wikiName=${wikiSchema.wikiName}`);
+            }
+        };
+        /**
+         * Registers a wiki schema with a given key
+         * @public
+         * @param {WikiName} key - The key to register the schema under
+         * @param {IWikiSchema} value - The wiki schema to register
+         */
+        this.register = (key, value) => {
+            GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO &&
+                this.loggerService.info(`wikiSchemaService register`, { key });
+            this.validateShallow(value);
+            this.registry = this.registry.register(key, value);
+        };
+        /**
+         * Retrieves a wiki schema by key
+         * @public
+         * @param {WikiName} key - The key of the schema to retrieve
+         * @returns {IWikiSchema} The registered wiki schema
+         */
+        this.get = (key) => {
+            GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO &&
+                this.loggerService.info(`wikiSchemaService get`, { key });
+            return this.registry.get(key);
+        };
+    }
+}
+
+/**
+ * @class WikiValidationService
+ * @description Service for managing and validating wiki configurations
+ */
+class WikiValidationService {
+    constructor() {
+        /**
+         * @private
+         * @readonly
+         * @description Injected logger service instance
+         */
+        this.loggerService = inject(TYPES.loggerService);
+        /**
+         * @private
+         * @description Map storing wiki schemas by wiki name
+         */
+        this._wikiMap = new Map();
+        /**
+         * Adds a wiki schema to the validation service
+         * @public
+         * @param {WikiName} wikiName - The name of the wiki
+         * @param {IWikiSchema} wikiSchema - The wiki schema to add
+         * @throws {Error} If wikiName already exists
+         */
+        this.addWiki = (wikiName, wikiSchema) => {
+            GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO &&
+                this.loggerService.info("wikiValidationService addWiki", {
+                    wikiName,
+                    wikiSchema,
+                });
+            if (this._wikiMap.has(wikiName)) {
+                throw new Error(`wiki-swarm wiki ${wikiName} already exist`);
+            }
+            this._wikiMap.set(wikiName, wikiSchema);
+        };
+        /**
+         * Validates the existence of a wiki
+         * @public
+         * @param {WikiName} wikiName - The name of the wiki to validate
+         * @param {string} source - The source requesting validation
+         * @throws {Error} If wikiName is not found
+         * @description Memoized function to cache validation results
+         */
+        this.validate = functoolsKit.memoize(([wikiName]) => wikiName, (wikiName, source) => {
+            GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO &&
+                this.loggerService.info("wikiValidationService validate", {
+                    wikiName,
+                    source,
+                });
+            const wiki = this._wikiMap.get(wikiName);
+            if (!wiki) {
+                throw new Error(`wiki-swarm wiki ${wikiName} not found source=${source}`);
+            }
+        });
+    }
+}
+
 {
     provide(TYPES.docService, () => new DocService());
     provide(TYPES.busService, () => new BusService());
@@ -13355,6 +13567,7 @@ class NavigationValidationService {
     provide(TYPES.stateSchemaService, () => new StateSchemaService());
     provide(TYPES.memorySchemaService, () => new MemorySchemaService());
     provide(TYPES.policySchemaService, () => new PolicySchemaService());
+    provide(TYPES.wikiSchemaService, () => new WikiSchemaService());
 }
 {
     provide(TYPES.agentPublicService, () => new AgentPublicService());
@@ -13381,6 +13594,7 @@ class NavigationValidationService {
     provide(TYPES.embeddingValidationService, () => new EmbeddingValidationService());
     provide(TYPES.policyValidationService, () => new PolicyValidationService());
     provide(TYPES.navigationValidationService, () => new NavigationValidationService());
+    provide(TYPES.wikiValidationService, () => new WikiValidationService());
 }
 
 const baseServices = {
@@ -13416,6 +13630,7 @@ const schemaServices = {
     stateSchemaService: inject(TYPES.stateSchemaService),
     memorySchemaService: inject(TYPES.memorySchemaService),
     policySchemaService: inject(TYPES.policySchemaService),
+    wikiSchemaService: inject(TYPES.wikiSchemaService),
 };
 const publicServices = {
     agentPublicService: inject(TYPES.agentPublicService),
@@ -13442,6 +13657,7 @@ const validationServices = {
     embeddingValidationService: inject(TYPES.embeddingValidationService),
     policyValidationService: inject(TYPES.policyValidationService),
     navigationValidationService: inject(TYPES.navigationValidationService),
+    wikiValidationService: inject(TYPES.wikiValidationService),
 };
 /** @inheritDoc */
 const swarm = {
@@ -13456,7 +13672,7 @@ const swarm = {
 init();
 var swarm$1 = swarm;
 
-const METHOD_NAME$Y = "cli.dumpDocs";
+const METHOD_NAME$$ = "cli.dumpDocs";
 /**
  * Dumps the documentation for the agents and swarms.
  *
@@ -13466,7 +13682,7 @@ const METHOD_NAME$Y = "cli.dumpDocs";
  */
 const dumpDocs = beginContext((prefix = "swarm", dirName = "./docs/chat", PlantUML) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$Y, {
+        swarm$1.loggerService.log(METHOD_NAME$$, {
             dirName,
         });
     if (PlantUML) {
@@ -13476,10 +13692,10 @@ const dumpDocs = beginContext((prefix = "swarm", dirName = "./docs/chat", PlantU
     }
     swarm$1.agentValidationService
         .getAgentList()
-        .forEach((agentName) => swarm$1.agentValidationService.validate(agentName, METHOD_NAME$Y));
+        .forEach((agentName) => swarm$1.agentValidationService.validate(agentName, METHOD_NAME$$));
     swarm$1.swarmValidationService
         .getSwarmList()
-        .forEach((swarmName) => swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$Y));
+        .forEach((swarmName) => swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$$));
     swarm$1.agentValidationService.getAgentList().forEach((agentName) => {
         const { dependsOn } = swarm$1.agentSchemaService.get(agentName);
         if (!dependsOn) {
@@ -13489,7 +13705,7 @@ const dumpDocs = beginContext((prefix = "swarm", dirName = "./docs/chat", PlantU
     return swarm$1.docService.dumpDocs(prefix, dirName);
 });
 
-const METHOD_NAME$X = "cli.dumpAgent";
+const METHOD_NAME$_ = "cli.dumpAgent";
 /**
  * Dumps the agent information into PlantUML format.
  *
@@ -13498,14 +13714,14 @@ const METHOD_NAME$X = "cli.dumpAgent";
  */
 const dumpAgent = beginContext((agentName, { withSubtree = false } = {}) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$X, {
+        swarm$1.loggerService.log(METHOD_NAME$_, {
             agentName,
         });
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$X);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$_);
     return swarm$1.agentMetaService.toUML(agentName, withSubtree);
 });
 
-const METHOD_NAME$W = "cli.dumpSwarm";
+const METHOD_NAME$Z = "cli.dumpSwarm";
 /**
  * Dumps the swarm information into PlantUML format.
  *
@@ -13514,14 +13730,14 @@ const METHOD_NAME$W = "cli.dumpSwarm";
  */
 const dumpSwarm = beginContext((swarmName) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$W, {
+        swarm$1.loggerService.log(METHOD_NAME$Z, {
             swarmName,
         });
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$W);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$Z);
     return swarm$1.swarmMetaService.toUML(swarmName);
 });
 
-const METHOD_NAME$V = "cli.dumpPerfomance";
+const METHOD_NAME$Y = "cli.dumpPerfomance";
 const METHOD_NAME_INTERNAL$1 = "cli.dumpPerfomance.internal";
 const METHOD_NAME_INTERVAL = "cli.dumpPerfomance.interval";
 /**
@@ -13540,7 +13756,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$V);
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$Y);
     await dumpPerfomanceInternal(dirName);
 };
 /**
@@ -13598,7 +13814,7 @@ const listenExecutionEvent = beginContext((clientId, fn) => {
     return swarm$1.busService.subscribe(clientId, "execution-bus", functoolsKit.queued(async (e) => await fn(e)));
 });
 
-const METHOD_NAME$U = "cli.dumpClientPerformance";
+const METHOD_NAME$X = "cli.dumpClientPerformance";
 const METHOD_NAME_INTERNAL = "cli.dumpClientPerformance.internal";
 const METHOD_NAME_EXECUTE = "cli.dumpClientPerformance.execute";
 /**
@@ -13622,7 +13838,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$U);
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$X);
     await dumpClientPerformanceInternal(clientId, dirName);
 };
 /**
@@ -13642,7 +13858,25 @@ dumpClientPerformance.runAfterExecute = beginContext(async (dirName = "./logs/cl
     });
 });
 
-const METHOD_NAME$T = "function.setup.addAgent";
+/** @constant {string} METHOD_NAME - The name of the method used for logging */
+const METHOD_NAME$W = "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$W, {
+            wikiSchema,
+        });
+    swarm$1.wikiValidationService.addWiki(wikiSchema.wikiName, wikiSchema);
+    swarm$1.wikiSchemaService.register(wikiSchema.wikiName, wikiSchema);
+    return wikiSchema.wikiName;
+});
+
+const METHOD_NAME$V = "function.setup.addAgent";
 /**
  * Adds a new agent to the agent registry for use within the swarm system.
  *
@@ -13662,7 +13896,7 @@ const METHOD_NAME$T = "function.setup.addAgent";
 const addAgent = beginContext((agentSchema) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$T, {
+        swarm$1.loggerService.log(METHOD_NAME$V, {
             agentSchema,
         });
     // Register the agent in the validation and schema services
@@ -13672,7 +13906,7 @@ const addAgent = beginContext((agentSchema) => {
     return agentSchema.agentName;
 });
 
-const METHOD_NAME$S = "function.setup.addCompletion";
+const METHOD_NAME$U = "function.setup.addCompletion";
 /**
  * Adds a completion engine to the registry for use by agents in the swarm system.
  *
@@ -13692,7 +13926,7 @@ const METHOD_NAME$S = "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$S, {
+        swarm$1.loggerService.log(METHOD_NAME$U, {
             completionSchema,
         });
     // Register the completion in the validation and schema services
@@ -13702,7 +13936,7 @@ const addCompletion = beginContext((completionSchema) => {
     return completionSchema.completionName;
 });
 
-const METHOD_NAME$R = "function.setup.addSwarm";
+const METHOD_NAME$T = "function.setup.addSwarm";
 /**
  * Adds a new swarm to the system for managing client sessions.
  *
@@ -13722,7 +13956,7 @@ const METHOD_NAME$R = "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$R, {
+        swarm$1.loggerService.log(METHOD_NAME$T, {
             swarmSchema,
         });
     // Register the swarm in the validation and schema services
@@ -13732,7 +13966,7 @@ const addSwarm = beginContext((swarmSchema) => {
     return swarmSchema.swarmName;
 });
 
-const METHOD_NAME$Q = "function.setup.addTool";
+const METHOD_NAME$S = "function.setup.addTool";
 /**
  * Adds a new tool to the tool registry for use by agents in the swarm system.
  *
@@ -13754,7 +13988,7 @@ const METHOD_NAME$Q = "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$Q, {
+        swarm$1.loggerService.log(METHOD_NAME$S, {
             toolSchema,
         });
     // Register the tool in the validation and schema services
@@ -13764,7 +13998,7 @@ const addTool = beginContext((toolSchema) => {
     return toolSchema.toolName;
 });
 
-const METHOD_NAME$P = "function.setup.addState";
+const METHOD_NAME$R = "function.setup.addState";
 /**
  * Adds a new state to the state registry for use within the swarm system.
  *
@@ -13786,7 +14020,7 @@ const METHOD_NAME$P = "function.setup.addState";
 const addState = beginContext((stateSchema) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$P, {
+        swarm$1.loggerService.log(METHOD_NAME$R, {
             stateSchema,
         });
     // Register the state in the schema service
@@ -13801,7 +14035,7 @@ const addState = beginContext((stateSchema) => {
     return stateSchema.stateName;
 });
 
-const METHOD_NAME$O = "function.setup.addEmbedding";
+const METHOD_NAME$Q = "function.setup.addEmbedding";
 /**
  * Adds a new embedding engine to the embedding registry for use within the swarm system.
  *
@@ -13821,7 +14055,7 @@ const METHOD_NAME$O = "function.setup.addEmbedding";
 const addEmbedding = beginContext((embeddingSchema) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$O, {
+        swarm$1.loggerService.log(METHOD_NAME$Q, {
             embeddingSchema,
         });
     // Register the embedding in the validation and schema services
@@ -13831,7 +14065,7 @@ const addEmbedding = beginContext((embeddingSchema) => {
     return embeddingSchema.embeddingName;
 });
 
-const METHOD_NAME$N = "function.setup.addStorage";
+const METHOD_NAME$P = "function.setup.addStorage";
 /**
  * Adds a new storage engine to the storage registry for use within the swarm system.
  *
@@ -13853,7 +14087,7 @@ const METHOD_NAME$N = "function.setup.addStorage";
 const addStorage = beginContext((storageSchema) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$N, {
+        swarm$1.loggerService.log(METHOD_NAME$P, {
             storageSchema,
         });
     // Register the storage in the validation and schema services
@@ -13870,7 +14104,7 @@ const addStorage = beginContext((storageSchema) => {
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$M = "function.setup.addPolicy";
+const METHOD_NAME$O = "function.setup.addPolicy";
 /**
  * Adds a new policy for agents in the swarm system by registering it with validation and schema services.
  * Registers the policy with PolicyValidationService for runtime validation and PolicySchemaService for schema management.
@@ -13886,7 +14120,7 @@ const METHOD_NAME$M = "function.setup.addPolicy";
 const addPolicy = beginContext((policySchema) => {
     // Log the policy addition attempt if enabled
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$M, {
+        swarm$1.loggerService.log(METHOD_NAME$O, {
             policySchema,
         });
     // Register the policy with PolicyValidationService for runtime validation
@@ -13897,7 +14131,7 @@ const addPolicy = beginContext((policySchema) => {
     return policySchema.policyName;
 });
 
-const METHOD_NAME$L = "function.other.markOnline";
+const METHOD_NAME$N = "function.other.markOnline";
 /**
  * Marks a client as online in the specified swarm.
  *
@@ -13909,16 +14143,16 @@ const METHOD_NAME$L = "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$L, {
+        swarm.loggerService.log(METHOD_NAME$N, {
             clientId,
         });
     // Validate the swarm name
-    swarm.swarmValidationService.validate(swarmName, METHOD_NAME$L);
+    swarm.swarmValidationService.validate(swarmName, METHOD_NAME$N);
     // Run the operation in the method context
     return await MethodContextService.runInContext(async () => {
-        await swarm.aliveService.markOnline(clientId, swarmName, METHOD_NAME$L);
+        await swarm.aliveService.markOnline(clientId, swarmName, METHOD_NAME$N);
     }, {
-        methodName: METHOD_NAME$L,
+        methodName: METHOD_NAME$N,
         agentName: "",
         policyName: "",
         stateName: "",
@@ -13928,7 +14162,7 @@ const markOnline = async (clientId, swarmName) => {
     });
 };
 
-const METHOD_NAME$K = "function.other.markOffline";
+const METHOD_NAME$M = "function.other.markOffline";
 /**
  * Marks a client as offline in the specified swarm.
  *
@@ -13943,14 +14177,14 @@ const METHOD_NAME$K = "function.other.markOffline";
  */
 const markOffline = async (clientId, swarmName) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm.loggerService.log(METHOD_NAME$K, {
+        swarm.loggerService.log(METHOD_NAME$M, {
             clientId,
         });
-    swarm.swarmValidationService.validate(swarmName, METHOD_NAME$K);
+    swarm.swarmValidationService.validate(swarmName, METHOD_NAME$M);
     return await MethodContextService.runInContext(async () => {
-        await swarm.aliveService.markOffline(clientId, swarmName, METHOD_NAME$K);
+        await swarm.aliveService.markOffline(clientId, swarmName, METHOD_NAME$M);
     }, {
-        methodName: METHOD_NAME$K,
+        methodName: METHOD_NAME$M,
         agentName: "",
         policyName: "",
         stateName: "",
@@ -13960,7 +14194,7 @@ const markOffline = async (clientId, swarmName) => {
     });
 };
 
-const METHOD_NAME$J = "function.commit.commitToolOutput";
+const METHOD_NAME$L = "function.commit.commitToolOutput";
 /**
  * Commits the output of a tool execution to the active agent in a swarm session.
  *
@@ -13980,19 +14214,19 @@ const METHOD_NAME$J = "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$J, {
+        swarm$1.loggerService.log(METHOD_NAME$L, {
             toolId,
             content,
             clientId,
             agentName,
         });
     // Validate the agent, session, and swarm to ensure they exist and are accessible
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$J);
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$J);
+    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$J);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$L);
     // Check if the specified agent is still the active agent in the swarm session
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$J, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$L, clientId, swarmName);
     if (currentAgentName !== agentName) {
         // Log a skip message if the agent has changed during the operation
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
@@ -14005,11 +14239,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$J, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitToolOutput(toolId, content, METHOD_NAME$L, clientId, swarmName);
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$I = "function.commit.commitSystemMessage";
+const METHOD_NAME$K = "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.
@@ -14028,20 +14262,20 @@ const METHOD_NAME$I = "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$I, {
+        swarm$1.loggerService.log(METHOD_NAME$K, {
             content,
             clientId,
             agentName,
         });
     // Validate the agent exists
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$I);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$K);
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$I);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$K);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$I);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$K);
     // Check if the current agent matches the provided agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$I, 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 "commitSystemMessage" skipped due to the agent change', {
@@ -14052,11 +14286,11 @@ const commitSystemMessage = beginContext(async (content, clientId, agentName) =>
         return;
     }
     // Commit the system message via SessionPublicService
-    await swarm$1.sessionPublicService.commitSystemMessage(content, METHOD_NAME$I, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitSystemMessage(content, METHOD_NAME$K, clientId, swarmName);
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$H = "function.commit.commitFlush";
+const METHOD_NAME$J = "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.
@@ -14073,19 +14307,19 @@ const METHOD_NAME$H = "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$H, {
+        swarm$1.loggerService.log(METHOD_NAME$J, {
             clientId,
             agentName,
         });
     // Validate the agent exists
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$H);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$J);
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$H);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$J);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$H);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$J);
     // Check if the current agent matches the provided agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$H, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$J, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "commitFlush" skipped due to the agent change', {
@@ -14096,10 +14330,10 @@ const commitFlush = beginContext(async (clientId, agentName) => {
         return;
     }
     // Commit the flush of agent history via SessionPublicService
-    await swarm$1.sessionPublicService.commitFlush(METHOD_NAME$H, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitFlush(METHOD_NAME$J, clientId, swarmName);
 });
 
-const METHOD_NAME$G = "function.commit.commitSystemMessage";
+const METHOD_NAME$I = "function.commit.commitSystemMessage";
 /**
  * Commits a user message to the active agent's history in a swarm session without triggering a response.
  *
@@ -14118,19 +14352,19 @@ const METHOD_NAME$G = "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$G, {
+        swarm$1.loggerService.log(METHOD_NAME$I, {
             content,
             clientId,
             agentName,
             mode,
         });
     // Validate the agent, session, and swarm to ensure they exist and are accessible
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$G);
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$G);
+    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$G);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$I);
     // Check if the specified agent is still the active agent in the swarm session
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$G, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$I, clientId, swarmName);
     if (currentAgentName !== agentName) {
         // Log a skip message if the agent has changed during the operation
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
@@ -14143,17 +14377,17 @@ const commitUserMessage = beginContext(async (content, mode, clientId, agentName
     }
     if (payload) {
         return await PayloadContextService.runInContext(async () => {
-            await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$G, clientId, swarmName);
+            await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$I, 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$G, clientId, swarmName);
+    return await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$I, clientId, swarmName);
 });
 
-const METHOD_NAME$F = "function.commit.commitToolOutputForce";
+const METHOD_NAME$H = "function.commit.commitToolOutputForce";
 /**
  * Commits the output of a tool execution to the active agent in a swarm session without checking the active agent.
  *
@@ -14172,21 +14406,21 @@ const METHOD_NAME$F = "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$F, {
+        swarm$1.loggerService.log(METHOD_NAME$H, {
             toolId,
             content,
             clientId,
         });
     // Validate the session and swarm to ensure they exist and are accessible
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$F);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$H);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$F);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$H);
     // 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$F, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitToolOutput(toolId, content, METHOD_NAME$H, clientId, swarmName);
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$E = "function.commit.commitSystemMessageForce";
+const METHOD_NAME$G = "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.
@@ -14205,21 +14439,21 @@ const METHOD_NAME$E = "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$E, {
+        swarm$1.loggerService.log(METHOD_NAME$G, {
             content,
             clientId,
         });
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$E);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$G);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$E);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$G);
     // Commit the system message via SessionPublicService without agent checks
-    await swarm$1.sessionPublicService.commitSystemMessage(content, METHOD_NAME$E, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitSystemMessage(content, METHOD_NAME$G, clientId, swarmName);
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$D = "function.commit.commitFlushForce";
+const METHOD_NAME$F = "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.
@@ -14237,20 +14471,20 @@ const METHOD_NAME$D = "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$D, {
+        swarm$1.loggerService.log(METHOD_NAME$F, {
             clientId,
-            METHOD_NAME: METHOD_NAME$D,
+            METHOD_NAME: METHOD_NAME$F,
         });
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$D);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$F);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$D);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$F);
     // Commit the flush of agent history via SessionPublicService without agent checks
-    await swarm$1.sessionPublicService.commitFlush(METHOD_NAME$D, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitFlush(METHOD_NAME$F, clientId, swarmName);
 });
 
-const METHOD_NAME$C = "function.commit.commitSystemMessage";
+const METHOD_NAME$E = "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.
  *
@@ -14268,29 +14502,29 @@ const METHOD_NAME$C = "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$C, {
+        swarm$1.loggerService.log(METHOD_NAME$E, {
             content,
             clientId,
             mode,
         });
     // Validate the session and swarm to ensure they exist and are accessible
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$C);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$E);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$C);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$E);
     if (payload) {
         return await PayloadContextService.runInContext(async () => {
-            await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$C, clientId, swarmName);
+            await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$E, 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$C, clientId, swarmName);
+    return await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$E, clientId, swarmName);
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$B = "function.commit.commitAssistantMessage";
+const METHOD_NAME$D = "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.
@@ -14308,20 +14542,20 @@ const METHOD_NAME$B = "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$B, {
+        swarm$1.loggerService.log(METHOD_NAME$D, {
             content,
             clientId,
             agentName,
         });
     // Validate the agent exists
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$B);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$D);
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$B);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$D);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$B);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$D);
     // Check if the current agent matches the provided agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$B, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$D, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "commitAssistantMessage" skipped due to the agent change', {
@@ -14332,11 +14566,11 @@ const commitAssistantMessage = beginContext(async (content, clientId, agentName)
         return;
     }
     // Commit the assistant message via SessionPublicService
-    await swarm$1.sessionPublicService.commitAssistantMessage(content, METHOD_NAME$B, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitAssistantMessage(content, METHOD_NAME$D, clientId, swarmName);
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$A = "function.commit.commitAssistantMessageForce";
+const METHOD_NAME$C = "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.
@@ -14355,21 +14589,21 @@ const METHOD_NAME$A = "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$A, {
+        swarm$1.loggerService.log(METHOD_NAME$C, {
             content,
             clientId,
         });
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$A);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$C);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$A);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$C);
     // Commit the assistant message via SessionPublicService without agent checks
-    await swarm$1.sessionPublicService.commitAssistantMessage(content, METHOD_NAME$A, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitAssistantMessage(content, METHOD_NAME$C, clientId, swarmName);
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$z = "function.commit.cancelOutput";
+const METHOD_NAME$B = "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.
@@ -14385,19 +14619,19 @@ const METHOD_NAME$z = "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$z, {
+        swarm$1.loggerService.log(METHOD_NAME$B, {
             clientId,
             agentName,
         });
     // Validate the agent exists
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$z);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$B);
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$z);
+    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$z);
+    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$z, 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 "cancelOutput" skipped due to the agent change', {
@@ -14408,11 +14642,11 @@ const cancelOutput = beginContext(async (clientId, agentName) => {
         return;
     }
     // Perform the output cancellation via SwarmPublicService
-    await swarm$1.swarmPublicService.cancelOutput(METHOD_NAME$z, clientId, swarmName);
+    await swarm$1.swarmPublicService.cancelOutput(METHOD_NAME$B, clientId, swarmName);
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$y = "function.commit.cancelOutputForce";
+const METHOD_NAME$A = "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.
@@ -14429,20 +14663,20 @@ const METHOD_NAME$y = "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$y, {
+        swarm$1.loggerService.log(METHOD_NAME$A, {
             clientId,
         });
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$y);
+    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$y);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$A);
     // Perform the output cancellation via SwarmPublicService without agent checks
-    await swarm$1.swarmPublicService.cancelOutput(METHOD_NAME$y, clientId, swarmName);
+    await swarm$1.swarmPublicService.cancelOutput(METHOD_NAME$A, clientId, swarmName);
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$x = "function.commit.commitStopTools";
+const METHOD_NAME$z = "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.
@@ -14459,19 +14693,19 @@ const METHOD_NAME$x = "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$x, {
+        swarm$1.loggerService.log(METHOD_NAME$z, {
             clientId,
             agentName,
         });
     // Validate the agent exists
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$x);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$z);
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$x);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$z);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$x);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$z);
     // 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$z, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "commitStopTools" skipped due to the agent change', {
@@ -14482,11 +14716,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$x, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitStopTools(METHOD_NAME$z, clientId, swarmName);
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$w = "function.commit.commitStopToolsForce";
+const METHOD_NAME$y = "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.
@@ -14504,20 +14738,20 @@ const METHOD_NAME$w = "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$w, {
+        swarm$1.loggerService.log(METHOD_NAME$y, {
             clientId,
-            METHOD_NAME: METHOD_NAME$w,
+            METHOD_NAME: METHOD_NAME$y,
         });
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$w);
+    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$w);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$y);
     // Commit the stop of the next tool execution via SessionPublicService without agent checks
-    await swarm$1.sessionPublicService.commitStopTools(METHOD_NAME$w, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitStopTools(METHOD_NAME$y, clientId, swarmName);
 });
 
-const METHOD_NAME$v = "function.target.emitForce";
+const METHOD_NAME$x = "function.target.emitForce";
 /**
  * Emits a string as model output without executing an incoming message or checking the active agent.
  *
@@ -14536,19 +14770,19 @@ const METHOD_NAME$v = "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$v, {
+        swarm$1.loggerService.log(METHOD_NAME$x, {
             content,
             clientId,
         });
     // Validate the session and swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$v);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$x);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$v);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$x);
     // Emit the content directly via the session public service
-    return await swarm$1.sessionPublicService.emit(content, METHOD_NAME$v, clientId, swarmName);
+    return await swarm$1.sessionPublicService.emit(content, METHOD_NAME$x, clientId, swarmName);
 });
 
-const METHOD_NAME$u = "function.target.executeForce";
+const METHOD_NAME$w = "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.
  *
@@ -14569,22 +14803,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$u, {
+        swarm$1.loggerService.log(METHOD_NAME$w, {
             content,
             clientId,
             executionId,
         });
     // Validate the session and swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$u);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$w);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$u);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$w);
     // 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$u, clientId, swarmName);
+            const result = await swarm$1.sessionPublicService.execute(content, "tool", METHOD_NAME$w, clientId, swarmName);
             isFinished = swarm$1.perfService.endExecution(executionId, clientId, result.length);
             swarm$1.busService.commitExecutionEnd(clientId, { swarmName });
             return result;
@@ -14601,6 +14835,86 @@ const executeForce = beginContext(async (content, clientId) => {
     });
 });
 
+/** @constant {string} METHOD_NAME - The name of the method used for logging and validation */
+const METHOD_NAME$v = "function.target.question";
+/**
+ * Initiates a question process within a chat context
+ * @function question
+ * @param {string} message - The message/question to be processed
+ * @param {string} clientId - Unique identifier for the client
+ * @param {AgentName} agentName - Name of the agent handling the question
+ * @param {WikiName} wikiName - Name of the wiki context
+ * @returns {Promise<string>} The response from the chat process
+ */
+const question = beginContext(async (message, clientId, agentName, wikiName) => {
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
+        swarm$1.loggerService.log(METHOD_NAME$v, {
+            message,
+            clientId,
+            agentName,
+            wikiName,
+        });
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$v);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$v);
+    const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$v);
+    swarm$1.wikiValidationService.validate(wikiName, METHOD_NAME$v);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$v, clientId, swarmName);
+    if (currentAgentName !== agentName) {
+        GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
+            swarm$1.loggerService.log('function "question" skipped due to the agent change', {
+                currentAgentName,
+                agentName,
+                clientId,
+            });
+        return "";
+    }
+    const { getChat, callbacks } = swarm$1.wikiSchemaService.get(wikiName);
+    const args = {
+        agentName,
+        clientId,
+        message,
+    };
+    if (callbacks?.onChat) {
+        callbacks.onChat(args);
+    }
+    return await getChat(args);
+});
+
+/** @constant {string} METHOD_NAME - The name of the method used for logging and validation */
+const METHOD_NAME$u = "function.target.questionForce";
+/**
+ * Initiates a forced question process within a chat context
+ * @function questionForce
+ * @param {string} message - The message/question to be processed
+ * @param {string} clientId - Unique identifier for the client
+ * @param {WikiName} wikiName - Name of the wiki context
+ * @returns {Promise<string>} The response from the chat process
+ */
+const questionForce = beginContext(async (message, clientId, wikiName) => {
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
+        swarm$1.loggerService.log(METHOD_NAME$u, {
+            message,
+            clientId,
+            wikiName,
+        });
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$u);
+    const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$u);
+    swarm$1.wikiValidationService.validate(wikiName, METHOD_NAME$u);
+    const { getChat, callbacks } = swarm$1.wikiSchemaService.get(wikiName);
+    const agentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$u, clientId, swarmName);
+    const args = {
+        clientId,
+        message,
+        agentName
+    };
+    if (callbacks?.onChat) {
+        callbacks.onChat(args);
+    }
+    return await getChat(args);
+});
+
 const METHOD_NAME$t = "function.target.disposeConnection";
 /**
  * Disposes of a client session and all related resources within a swarm.
@@ -14936,19 +15250,17 @@ const METHOD_NAME$o = "function.target.notifyForce";
  *
  * @param {string} content - The content to be sent as the notification output.
  * @param {string} clientId - The unique identifier of the client session sending the notification.
- * @param {AgentName} agentName - The name of the agent intended to send the notification.
  * @returns {Promise<void>} A promise that resolves when the notification is sent
  * @throws {Error} If the session mode is not "makeConnection", or if agent, session, or swarm validation fails.
  * @example
  * await notifyForce("Direct output", "client-123", "AgentX"); // Sends "Direct output" if AgentX is active
  */
-const notifyForce = beginContext(async (content, clientId, agentName) => {
+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$o, {
             content,
             clientId,
-            agentName,
         });
     swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$o);
     // Check if the session mode is "makeConnection"
@@ -14957,11 +15269,8 @@ const notifyForce = beginContext(async (content, clientId, agentName) => {
         throw new Error(`agent-swarm-kit notifyForce session is not makeConnection clientId=${clientId}`);
     }
     // Validate the agent, session, and swarm
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$o);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$o);
-    // Check if the specified agent is still the active agent
-    await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$o, clientId, swarmName);
     // Notify the content directly via the session public service
     return await swarm$1.sessionPublicService.notify(content, METHOD_NAME$o, clientId, swarmName);
 });
@@ -18491,6 +18800,7 @@ exports.addState = addState;
 exports.addStorage = addStorage;
 exports.addSwarm = addSwarm;
 exports.addTool = addTool;
+exports.addWiki = addWiki;
 exports.beginContext = beginContext;
 exports.cancelOutput = cancelOutput;
 exports.cancelOutputForce = cancelOutputForce;
@@ -18559,6 +18869,8 @@ exports.markOffline = markOffline;
 exports.markOnline = markOnline;
 exports.notify = notify;
 exports.notifyForce = notifyForce;
+exports.question = question;
+exports.questionForce = questionForce;
 exports.runStateless = runStateless;
 exports.runStatelessForce = runStatelessForce;
 exports.session = session;