agent-swarm-kit 1.1.1 → 1.1.2

package/build/index.cjs

@@ -3445,6 +3445,21 @@ class AgentSchemaService {
             this.validateShallow(value);
             this.registry = this.registry.register(key, value);
         };
+        /**
+         * Overrides an existing agent schema in the registry with a new schema.
+         * Replaces the schema associated with the provided key (agentName) in the ToolRegistry.
+         * Logs the override operation via LoggerService if GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO is true.
+         * Supports dynamic updates to agent schemas for AgentConnectionService and SwarmConnectionService.
+         * @param {AgentName} key - The name of the agent, used as the registry key, sourced from Agent.interface.
+         * @param {IAgentSchema} value - The new agent schema to override the existing one, sourced from Agent.interface.
+         * @throws {Error} If the key does not exist in the registry (inherent to ToolRegistry.override behavior).
+         */
+        this.override = (key, value) => {
+            GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO &&
+                this.loggerService.info(`agentSchemaService override`, { key });
+            this.registry = this.registry.override(key, value);
+            return this.registry.get(key);
+        };
         /**
          * Retrieves an agent schema from the registry by its name.
          * Fetches the schema from ToolRegistry using the provided key, logging the operation via LoggerService if GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO is true.
@@ -4820,7 +4835,7 @@ class AgentConnectionService {
 }
 
 /** @private Constant defining the method name for logging purposes */
-const METHOD_NAME$10 = "function.common.getPayload";
+const METHOD_NAME$19 = "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.
@@ -4831,7 +4846,7 @@ const METHOD_NAME$10 = "function.common.getPayload";
  * console.log(payload); // { id: number } or null
  */
 const getPayload = () => {
-    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$10);
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$19);
     if (PayloadContextService.hasContext()) {
         const { payload } = swarm$1.payloadContextService.context;
         return payload;
@@ -5227,6 +5242,21 @@ class ToolSchemaService {
             this.validateShallow(value);
             this.registry = this.registry.register(key, value);
         };
+        /**
+         * Overrides an existing tool schema in the registry with a new schema.
+         * Replaces the schema associated with the provided key (toolName) in the ToolRegistry.
+         * Logs the override operation via LoggerService if GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO is true.
+         * Supports dynamic updates to tool schemas for AgentConnectionService and SwarmConnectionService.
+         * @param {ToolName} key - The name of the tool to override, sourced from Agent.interface.
+         * @param {IAgentTool} value - The new tool schema to replace the existing one, sourced from Agent.interface.
+         * @throws {Error} If the key does not exist in the registry (inherent to ToolRegistry.override behavior).
+         */
+        this.override = (key, value) => {
+            GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO &&
+                this.loggerService.info(`toolSchemaService override`, { key });
+            this.registry = this.registry.override(key, value);
+            return this.registry.get(key);
+        };
         /**
          * Retrieves a tool schema from the registry by its name.
          * Fetches the schema from ToolRegistry using the provided key, logging the operation via LoggerService if GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO is true.
@@ -5993,6 +6023,21 @@ class SwarmSchemaService {
             this.validateShallow(value);
             this.registry = this.registry.register(key, value);
         };
+        /**
+         * Overrides an existing swarm schema in the registry with a new value.
+         * Replaces the schema associated with the given key in the ToolRegistry.
+         * Logs the override operation via LoggerService if GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO is true.
+         * Supports dynamic updates to swarm configurations, allowing modifications to agentList, defaultAgent, or policies.
+         * @param {SwarmName} key - The name of the swarm to override, sourced from Swarm.interface.
+         * @param {ISwarmSchema} value - The new swarm schema to replace the existing one, sourced from Swarm.interface.
+         * @throws {Error} If the key does not exist in the registry (inherent to ToolRegistry.override behavior).
+         */
+        this.override = (key, value) => {
+            GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO &&
+                this.loggerService.info(`swarmSchemaService override`, { key });
+            this.registry = this.registry.override(key, value);
+            return this.registry.get(key);
+        };
         /**
          * Retrieves a swarm schema from the registry by its name.
          * Fetches the schema from ToolRegistry using the provided key, logging the operation via LoggerService if GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO is true.
@@ -6069,6 +6114,21 @@ class CompletionSchemaService {
             this.validateShallow(value);
             this.registry = this.registry.register(key, value);
         };
+        /**
+         * Overrides an existing completion schema in the registry with a new one.
+         * Replaces the schema associated with the provided key in the ToolRegistry.
+         * Logs the override operation via LoggerService if GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO is true.
+         * Supports dynamic updates to completion schemas used by AgentSchemaService, ClientAgent, and other swarm components.
+         * @param {CompletionName} key - The name of the completion to override, sourced from Completion.interface.
+         * @param {ICompletionSchema} value - The new completion schema to replace the existing one, sourced from Completion.interface.
+         * @throws {Error} If the key does not exist in the registry (inherent to ToolRegistry.override behavior).
+         */
+        this.override = (key, value) => {
+            GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO &&
+                this.loggerService.info(`completionSchemaService override`, { key });
+            this.registry = this.registry.override(key, value);
+            return this.registry.get(key);
+        };
         /**
          * Retrieves a completion schema from the registry by its name.
          * Fetches the schema from ToolRegistry using the provided key, logging the operation via LoggerService if GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO is true.
@@ -9276,6 +9336,21 @@ class EmbeddingSchemaService {
             this.validateShallow(value);
             this.registry = this.registry.register(key, value);
         };
+        /**
+         * Overrides an existing embedding schema in the registry with a new one.
+         * Replaces the schema associated with the provided key in the ToolRegistry.
+         * Logs the override operation via LoggerService if GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO is true.
+         * Supports updating embedding logic (e.g., calculateSimilarity and createEmbedding) for storage operations in StorageConnectionService and SharedStorageConnectionService.
+         * @param {EmbeddingName} key - The name of the embedding to override, sourced from Embedding.interface.
+         * @param {IEmbeddingSchema} value - The new embedding schema to associate with the key, sourced from Embedding.interface.
+         * @throws {Error} If the key does not exist in the registry (inherent to ToolRegistry.override behavior).
+         */
+        this.override = (key, value) => {
+            GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO &&
+                this.loggerService.info(`embeddingSchemaService override`, { key });
+            this.registry = this.registry.override(key, value);
+            return this.registry.get(key);
+        };
         /**
          * Retrieves an embedding schema from the registry by its name.
          * Fetches the schema from ToolRegistry using the provided key, logging the operation via LoggerService if GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO is true.
@@ -9355,6 +9430,21 @@ class StorageSchemaService {
             this.validateShallow(value);
             this.registry = this.registry.register(key, value);
         };
+        /**
+         * Overrides an existing storage schema in the registry with a new schema.
+         * Replaces the schema associated with the provided key in the ToolRegistry.
+         * Logs the override operation via LoggerService if GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO is true.
+         * Supports updates to storage configurations for ClientStorage and SharedStorageConnectionService.
+         * @param {StorageName} key - The name of the storage to override, sourced from Storage.interface.
+         * @param {IStorageSchema} value - The new storage schema to replace the existing one, sourced from Storage.interface.
+         * @throws {Error} If the key does not exist in the registry (inherent to ToolRegistry.override behavior).
+         */
+        this.override = (key, value) => {
+            GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO &&
+                this.loggerService.info(`storageSchemaService override`, { key });
+            this.registry = this.registry.override(key, value);
+            return this.registry.get(key);
+        };
         /**
          * Retrieves a storage schema from the registry by its name.
          * Fetches the schema from ToolRegistry using the provided key, logging the operation via LoggerService if GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO is true.
@@ -10475,6 +10565,21 @@ class StateSchemaService {
             this.validateShallow(value);
             this.registry = this.registry.register(key, value);
         };
+        /**
+         * Overrides an existing state schema in the registry with a new schema.
+         * Replaces the schema associated with the provided key (stateName) in the ToolRegistry.
+         * Logs the override operation via LoggerService if GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO is true.
+         * Supports dynamic updates to state schemas for StateConnectionService and SharedStateConnectionService.
+         * @param {StateName} key - The name of the state to override, sourced from State.interface.
+         * @param {IStateSchema} value - The new state schema to replace the existing one, sourced from State.interface.
+         * @throws {Error} If the key does not exist in the registry (inherent to ToolRegistry.override behavior).
+         */
+        this.override = (key, value) => {
+            GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO &&
+                this.loggerService.info(`stateSchemaService override`, { key });
+            this.registry = this.registry.override(key, value);
+            return this.registry.get(key);
+        };
         /**
          * Retrieves a state schema from the registry by its name.
          * Fetches the schema from ToolRegistry using the provided key, logging the operation via LoggerService if GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO is true.
@@ -13262,6 +13367,21 @@ class PolicySchemaService {
             this.validateShallow(value);
             this.registry = this.registry.register(key, value);
         };
+        /**
+         * Overrides an existing policy schema in the registry with a new one.
+         * Replaces the schema associated with the provided key (policyName) in the ToolRegistry.
+         * Logs the override operation via LoggerService if GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO is true.
+         * Supports dynamic updates to policy schemas, ensuring the latest logic is applied in ClientAgent execution and SessionConnectionService.
+         * @param {PolicyName} key - The name of the policy to override, sourced from Policy.interface.
+         * @param {IPolicySchema} value - The new policy schema to replace the existing one, validated before storage.
+         * @throws {Error} If the key does not exist in the registry (inherent to ToolRegistry.override behavior).
+         */
+        this.override = (key, value) => {
+            GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO &&
+                this.loggerService.info(`policySchemaService override`, { key });
+            this.registry = this.registry.override(key, value);
+            return this.registry.get(key);
+        };
         /**
          * Retrieves a policy schema from the registry by its name.
          * Fetches the schema from ToolRegistry using the provided key, logging the operation via LoggerService if GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO is true.
@@ -14173,6 +14293,19 @@ class WikiSchemaService {
             this.validateShallow(value);
             this.registry = this.registry.register(key, value);
         };
+        /**
+         * Overrides an existing wiki schema with a new value for a given key
+         * @public
+         * @param {WikiName} key - The key of the schema to override
+         * @param {IWikiSchema} value - The new wiki schema to set
+         * @description Logs the override operation and updates the registry with the new schema
+         */
+        this.override = (key, value) => {
+            GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO &&
+                this.loggerService.info(`wikiSchemaService override`, { key });
+            this.registry = this.registry.override(key, value);
+            return this.registry.get(key);
+        };
         /**
          * Retrieves a wiki schema by key
          * @public
@@ -14382,7 +14515,7 @@ const swarm = {
 init();
 var swarm$1 = swarm;
 
-const METHOD_NAME$$ = "cli.dumpDocs";
+const METHOD_NAME$18 = "cli.dumpDocs";
 /**
  * Dumps the documentation for the agents and swarms.
  *
@@ -14392,7 +14525,7 @@ const METHOD_NAME$$ = "cli.dumpDocs";
  */
 const dumpDocs = beginContext((prefix = "swarm", dirName = "./docs/chat", PlantUML) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$$, {
+        swarm$1.loggerService.log(METHOD_NAME$18, {
             dirName,
         });
     if (PlantUML) {
@@ -14402,10 +14535,10 @@ const dumpDocs = beginContext((prefix = "swarm", dirName = "./docs/chat", PlantU
     }
     swarm$1.agentValidationService
         .getAgentList()
-        .forEach((agentName) => swarm$1.agentValidationService.validate(agentName, METHOD_NAME$$));
+        .forEach((agentName) => swarm$1.agentValidationService.validate(agentName, METHOD_NAME$18));
     swarm$1.swarmValidationService
         .getSwarmList()
-        .forEach((swarmName) => swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$$));
+        .forEach((swarmName) => swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$18));
     swarm$1.agentValidationService.getAgentList().forEach((agentName) => {
         const { dependsOn } = swarm$1.agentSchemaService.get(agentName);
         if (!dependsOn) {
@@ -14415,7 +14548,7 @@ const dumpDocs = beginContext((prefix = "swarm", dirName = "./docs/chat", PlantU
     return swarm$1.docService.dumpDocs(prefix, dirName);
 });
 
-const METHOD_NAME$_ = "cli.dumpAgent";
+const METHOD_NAME$17 = "cli.dumpAgent";
 /**
  * Dumps the agent information into PlantUML format.
  *
@@ -14424,14 +14557,14 @@ const METHOD_NAME$_ = "cli.dumpAgent";
  */
 const dumpAgent = beginContext((agentName, { withSubtree = false } = {}) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$_, {
+        swarm$1.loggerService.log(METHOD_NAME$17, {
             agentName,
         });
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$_);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$17);
     return swarm$1.agentMetaService.toUML(agentName, withSubtree);
 });
 
-const METHOD_NAME$Z = "cli.dumpSwarm";
+const METHOD_NAME$16 = "cli.dumpSwarm";
 /**
  * Dumps the swarm information into PlantUML format.
  *
@@ -14440,14 +14573,14 @@ const METHOD_NAME$Z = "cli.dumpSwarm";
  */
 const dumpSwarm = beginContext((swarmName) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$Z, {
+        swarm$1.loggerService.log(METHOD_NAME$16, {
             swarmName,
         });
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$Z);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$16);
     return swarm$1.swarmMetaService.toUML(swarmName);
 });
 
-const METHOD_NAME$Y = "cli.dumpPerfomance";
+const METHOD_NAME$15 = "cli.dumpPerfomance";
 const METHOD_NAME_INTERNAL$1 = "cli.dumpPerfomance.internal";
 const METHOD_NAME_INTERVAL = "cli.dumpPerfomance.interval";
 /**
@@ -14466,7 +14599,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$Y);
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$15);
     await dumpPerfomanceInternal(dirName);
 };
 /**
@@ -14524,7 +14657,7 @@ const listenExecutionEvent = beginContext((clientId, fn) => {
     return swarm$1.busService.subscribe(clientId, "execution-bus", functoolsKit.queued(async (e) => await fn(e)));
 });
 
-const METHOD_NAME$X = "cli.dumpClientPerformance";
+const METHOD_NAME$14 = "cli.dumpClientPerformance";
 const METHOD_NAME_INTERNAL = "cli.dumpClientPerformance.internal";
 const METHOD_NAME_EXECUTE = "cli.dumpClientPerformance.execute";
 /**
@@ -14548,7 +14681,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$X);
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$14);
     await dumpClientPerformanceInternal(clientId, dirName);
 };
 /**
@@ -14569,7 +14702,7 @@ dumpClientPerformance.runAfterExecute = beginContext(async (dirName = "./logs/cl
 });
 
 /** @constant {string} METHOD_NAME - The name of the method used for logging */
-const METHOD_NAME$W = "function.setup.addWiki";
+const METHOD_NAME$13 = "function.setup.addWiki";
 /**
  * Adds a wiki schema to the system
  * @function addWiki
@@ -14578,7 +14711,7 @@ const METHOD_NAME$W = "function.setup.addWiki";
  */
 const addWiki = beginContext((wikiSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$W, {
+        swarm$1.loggerService.log(METHOD_NAME$13, {
             wikiSchema,
         });
     swarm$1.wikiValidationService.addWiki(wikiSchema.wikiName, wikiSchema);
@@ -14586,7 +14719,7 @@ const addWiki = beginContext((wikiSchema) => {
     return wikiSchema.wikiName;
 });
 
-const METHOD_NAME$V = "function.setup.addAgent";
+const METHOD_NAME$12 = "function.setup.addAgent";
 /**
  * Adds a new agent to the agent registry for use within the swarm system.
  *
@@ -14606,7 +14739,7 @@ const METHOD_NAME$V = "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$V, {
+        swarm$1.loggerService.log(METHOD_NAME$12, {
             agentSchema,
         });
     // Register the agent in the validation and schema services
@@ -14616,7 +14749,7 @@ const addAgent = beginContext((agentSchema) => {
     return agentSchema.agentName;
 });
 
-const METHOD_NAME$U = "function.setup.addCompletion";
+const METHOD_NAME$11 = "function.setup.addCompletion";
 /**
  * Adds a completion engine to the registry for use by agents in the swarm system.
  *
@@ -14636,7 +14769,7 @@ const METHOD_NAME$U = "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$U, {
+        swarm$1.loggerService.log(METHOD_NAME$11, {
             completionSchema,
         });
     // Register the completion in the validation and schema services
@@ -14646,7 +14779,7 @@ const addCompletion = beginContext((completionSchema) => {
     return completionSchema.completionName;
 });
 
-const METHOD_NAME$T = "function.setup.addSwarm";
+const METHOD_NAME$10 = "function.setup.addSwarm";
 /**
  * Adds a new swarm to the system for managing client sessions.
  *
@@ -14666,7 +14799,7 @@ const METHOD_NAME$T = "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$T, {
+        swarm$1.loggerService.log(METHOD_NAME$10, {
             swarmSchema,
         });
     // Register the swarm in the validation and schema services
@@ -14676,7 +14809,7 @@ const addSwarm = beginContext((swarmSchema) => {
     return swarmSchema.swarmName;
 });
 
-const METHOD_NAME$S = "function.setup.addTool";
+const METHOD_NAME$$ = "function.setup.addTool";
 /**
  * Adds a new tool to the tool registry for use by agents in the swarm system.
  *
@@ -14698,7 +14831,7 @@ const METHOD_NAME$S = "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$S, {
+        swarm$1.loggerService.log(METHOD_NAME$$, {
             toolSchema,
         });
     // Register the tool in the validation and schema services
@@ -14708,7 +14841,7 @@ const addTool = beginContext((toolSchema) => {
     return toolSchema.toolName;
 });
 
-const METHOD_NAME$R = "function.setup.addState";
+const METHOD_NAME$_ = "function.setup.addState";
 /**
  * Adds a new state to the state registry for use within the swarm system.
  *
@@ -14730,7 +14863,7 @@ const METHOD_NAME$R = "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$R, {
+        swarm$1.loggerService.log(METHOD_NAME$_, {
             stateSchema,
         });
     // Register the state in the schema service
@@ -14745,7 +14878,7 @@ const addState = beginContext((stateSchema) => {
     return stateSchema.stateName;
 });
 
-const METHOD_NAME$Q = "function.setup.addEmbedding";
+const METHOD_NAME$Z = "function.setup.addEmbedding";
 /**
  * Adds a new embedding engine to the embedding registry for use within the swarm system.
  *
@@ -14765,7 +14898,7 @@ const METHOD_NAME$Q = "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$Q, {
+        swarm$1.loggerService.log(METHOD_NAME$Z, {
             embeddingSchema,
         });
     // Register the embedding in the validation and schema services
@@ -14775,7 +14908,7 @@ const addEmbedding = beginContext((embeddingSchema) => {
     return embeddingSchema.embeddingName;
 });
 
-const METHOD_NAME$P = "function.setup.addStorage";
+const METHOD_NAME$Y = "function.setup.addStorage";
 /**
  * Adds a new storage engine to the storage registry for use within the swarm system.
  *
@@ -14797,7 +14930,7 @@ const METHOD_NAME$P = "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$P, {
+        swarm$1.loggerService.log(METHOD_NAME$Y, {
             storageSchema,
         });
     // Register the storage in the validation and schema services
@@ -14814,7 +14947,7 @@ const addStorage = beginContext((storageSchema) => {
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$O = "function.setup.addPolicy";
+const METHOD_NAME$X = "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.
@@ -14830,7 +14963,7 @@ const METHOD_NAME$O = "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$O, {
+        swarm$1.loggerService.log(METHOD_NAME$X, {
             policySchema,
         });
     // Register the policy with PolicyValidationService for runtime validation
@@ -14841,6 +14974,281 @@ const addPolicy = beginContext((policySchema) => {
     return policySchema.policyName;
 });
 
+const METHOD_NAME$W = "function.test.overrideAgent";
+/**
+ * Overrides an existing agent schema in the swarm system with a new or partial schema.
+ * This function updates the configuration of an agent identified by its `agentName`, applying the provided schema properties.
+ * It operates outside any existing method or execution contexts to ensure isolation, leveraging `beginContext` for a clean execution scope.
+ * Logs the override operation if logging is enabled in the global configuration.
+ *
+ * @param {TAgentSchema} agentSchema - The schema containing the agent’s unique name and optional properties to override.
+ * @param {string} agentSchema.agentName - The unique identifier of the agent to override, matching `IAgentSchema["agentName"]`.
+ * @param {Partial<IAgentSchema>} [agentSchema] - Optional partial schema properties to update, extending `IAgentSchema`.
+ * @returns {void} No return value; the override is applied directly to the swarm’s agent schema service.
+ * @throws {Error} If the agent schema service encounters an error during the override operation (e.g., invalid agentName or schema).
+ *
+ * @example
+ * // Override an agent’s schema with new properties
+ * overrideAgent({
+ *   agentName: "WeatherAgent",
+ *   description: "Updated weather query handler",
+ *   tools: ["getWeather"],
+ * });
+ * // Logs the operation (if enabled) and updates the agent schema in the swarm.
+ */
+const overrideAgent = beginContext((agentSchema) => {
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
+        swarm$1.loggerService.log(METHOD_NAME$W, {
+            agentSchema,
+        });
+    return swarm$1.agentSchemaService.override(agentSchema.agentName, agentSchema);
+});
+
+const METHOD_NAME$V = "function.test.overrideCompletion";
+/**
+ * Overrides an existing completion schema in the swarm system with a new or partial schema.
+ * This function updates the configuration of a completion mechanism identified by its `completionName`, applying the provided schema properties.
+ * It operates outside any existing method or execution contexts to ensure isolation, leveraging `beginContext` for a clean execution scope.
+ * Logs the override operation if logging is enabled in the global configuration.
+ *
+ * @param {TCompletionSchema} completionSchema - The schema containing the completion’s unique name and optional properties to override.
+ * @param {string} completionSchema.completionName - The unique identifier of the completion to override, matching `ICompletionSchema["completionName"]`.
+ * @param {Partial<ICompletionSchema>} [completionSchema] - Optional partial schema properties to update, extending `ICompletionSchema`.
+ * @returns {void} No return value; the override is applied directly to the swarm’s completion schema service.
+ * @throws {Error} If the completion schema service encounters an error during the override operation (e.g., invalid completionName or schema).
+ *
+ * @example
+ * // Override a completion’s schema with new properties
+ * overrideCompletion({
+ *   completionName: "TextCompletion",
+ *   model: "gpt-4",
+ *   maxTokens: 500,
+ * });
+ * // Logs the operation (if enabled) and updates the completion schema in the swarm.
+ */
+const overrideCompletion = beginContext((completionSchema) => {
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
+        swarm$1.loggerService.log(METHOD_NAME$V, {
+            completionSchema,
+        });
+    return swarm$1.completionSchemaService.override(completionSchema.completionName, completionSchema);
+});
+
+const METHOD_NAME$U = "function.test.overrideEmbeding";
+/**
+ * Overrides an existing embedding schema in the swarm system with a new or partial schema.
+ * This function updates the configuration of an embedding mechanism identified by its `embeddingName`, applying the provided schema properties.
+ * It operates outside any existing method or execution contexts to ensure isolation, leveraging `beginContext` for a clean execution scope.
+ * Logs the override operation if logging is enabled in the global configuration.
+ *
+ * @param {TEmbeddingSchema} embeddingSchema - The schema containing the embedding’s unique name and optional properties to override.
+ * @param {string} embeddingSchema.embeddingName - The unique identifier of the embedding to override, matching `IEmbeddingSchema["embeddingName"]`.
+ * @param {Partial<IEmbeddingSchema>} [embeddingSchema] - Optional partial schema properties to update, extending `IEmbeddingSchema`.
+ * @returns {void} No return value; the override is applied directly to the swarm’s embedding schema service.
+ * @throws {Error} If the embedding schema service encounters an error during the override operation (e.g., invalid embeddingName or schema).
+ *
+ * @example
+ * // Override an embedding’s schema with new properties
+ * overrideEmbeding({
+ *   embeddingName: "TextEmbedding",
+ *   persist: true,
+ *   callbacks: {
+ *     onCreate: (text, embeddings) => console.log(`Created embedding for ${text}`),
+ *   },
+ * });
+ * // Logs the operation (if enabled) and updates the embedding schema in the swarm.
+ */
+const overrideEmbeding = beginContext((embeddingSchema) => {
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
+        swarm$1.loggerService.log(METHOD_NAME$U, {
+            embeddingSchema,
+        });
+    return swarm$1.embeddingSchemaService.override(embeddingSchema.embeddingName, embeddingSchema);
+});
+
+const METHOD_NAME$T = "function.test.overridePolicy";
+/**
+ * Overrides an existing policy schema in the swarm system with a new or partial schema.
+ * This function updates the configuration of a policy identified by its `policyName`, applying the provided schema properties.
+ * It operates outside any existing method or execution contexts to ensure isolation, leveraging `beginContext` for a clean execution scope.
+ * Logs the override operation if logging is enabled in the global configuration.
+ *
+ * @param {TPolicySchema} policySchema - The schema containing the policy’s unique name and optional properties to override.
+ * @param {string} policySchema.policyName - The unique identifier of the policy to override, matching `IPolicySchema["policyName"]`.
+ * @param {Partial<IPolicySchema>} [policySchema] - Optional partial schema properties to update, extending `IPolicySchema`.
+ * @returns {void} No return value; the override is applied directly to the swarm’s policy schema service.
+ * @throws {Error} If the policy schema service encounters an error during the override operation (e.g., invalid policyName or schema).
+ *
+ * @example
+ * // Override a policy’s schema with new properties
+ * overridePolicy({
+ *   policyName: "ContentFilter",
+ *   autoBan: true,
+ *   banMessage: "Content policy violation detected.",
+ * });
+ * // Logs the operation (if enabled) and updates the policy schema in the swarm.
+ */
+const overridePolicy = beginContext((policySchema) => {
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
+        swarm$1.loggerService.log(METHOD_NAME$T, {
+            policySchema,
+        });
+    return swarm$1.policySchemaService.override(policySchema.policyName, policySchema);
+});
+
+const METHOD_NAME$S = "function.test.overrideState";
+/**
+ * Overrides an existing state schema in the swarm system with a new or partial schema.
+ * This function updates the configuration of a state identified by its `stateName`, applying the provided schema properties.
+ * It operates outside any existing method or execution contexts to ensure isolation, leveraging `beginContext` for a clean execution scope.
+ * Logs the override operation if logging is enabled in the global configuration.
+ *
+ * @template T - The type of the state data, defaults to `any`.
+ * @param {TStateSchema<T>} stateSchema - The schema containing the state’s unique name and optional properties to override.
+ * @param {string} stateSchema.stateName - The unique identifier of the state to override, matching `IStateSchema<T>["stateName"]`.
+ * @param {Partial<IStateSchema<T>>} [stateSchema] - Optional partial schema properties to update, extending `IStateSchema<T>`.
+ * @returns {IStateSchema<T>} The updated state schema as applied by the swarm’s state schema service.
+ * @throws {Error} If the state schema service encounters an error during the override operation (e.g., invalid stateName or schema).
+ *
+ * @example
+ * // Override a state’s schema with new properties
+ * overrideState({
+ *   stateName: "UserPreferences",
+ *   persist: true,
+ *   getDefaultState: () => ({ theme: "dark" }),
+ * });
+ * // Logs the operation (if enabled) and updates the state schema in the swarm.
+ */
+const overrideState = beginContext((stateSchema) => {
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
+        swarm$1.loggerService.log(METHOD_NAME$S, {
+            stateSchema,
+        });
+    return swarm$1.stateSchemaService.override(stateSchema.stateName, stateSchema);
+});
+
+const METHOD_NAME$R = "function.test.overrideStorage";
+/**
+ * Overrides an existing storage schema in the swarm system with a new or partial schema.
+ * This function updates the configuration of a storage identified by its `storageName`, applying the provided schema properties.
+ * It operates outside any existing method or execution contexts to ensure isolation, leveraging `beginContext` for a clean execution scope.
+ * Logs the override operation if logging is enabled in the global configuration.
+ *
+ * @template T - The type of the storage data, defaults to `IStorageData`.
+ * @param {TStorageSchema<T>} storageSchema - The schema containing the storage’s unique name and optional properties to override.
+ * @param {string} storageSchema.storageName - The unique identifier of the storage to override, matching `IStorageSchema<T>["storageName"]`.
+ * @param {Partial<IStorageSchema<T>>} [storageSchema] - Optional partial schema properties to update, extending `IStorageSchema<T>`.
+ * @returns {IStorageSchema<T>} The updated storage schema as applied by the swarm’s storage schema service.
+ * @throws {Error} If the storage schema service encounters an error during the override operation (e.g., invalid storageName or schema).
+ *
+ * @example
+ * // Override a storage’s schema with new properties
+ * overrideStorage({
+ *   storageName: "UserData",
+ *   persist: true,
+ *   embedding: "TextEmbedding",
+ *   createIndex: (item) => item.id.toString(),
+ * });
+ * // Logs the operation (if enabled) and updates the storage schema in the swarm.
+ */
+const overrideStorage = beginContext((storageSchema) => {
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
+        swarm$1.loggerService.log(METHOD_NAME$R, {
+            storageSchema,
+        });
+    return swarm$1.storageSchemaService.override(storageSchema.storageName, storageSchema);
+});
+
+const METHOD_NAME$Q = "function.test.overrideSwarm";
+/**
+ * Overrides an existing swarm schema in the swarm system with a new or partial schema.
+ * This function updates the configuration of a swarm identified by its `swarmName`, applying the provided schema properties.
+ * It operates outside any existing method or execution contexts to ensure isolation, leveraging `beginContext` for a clean execution scope.
+ * Logs the override operation if logging is enabled in the global configuration.
+ *
+ * @param {TSwarmSchema} swarmSchema - The schema containing the swarm’s unique name and optional properties to override.
+ * @param {string} swarmSchema.swarmName - The unique identifier of the swarm to override, matching `ISwarmSchema["swarmName"]`.
+ * @param {Partial<ISwarmSchema>} [swarmSchema] - Optional partial schema properties to update, extending `ISwarmSchema`.
+ * @returns {void} No return value; the override is applied directly to the swarm’s swarm schema service.
+ * @throws {Error} If the swarm schema service encounters an error during the override operation (e.g., invalid swarmName or schema).
+ *
+ * @example
+ * // Override a swarm’s schema with new properties
+ * overrideSwarm({
+ *   swarmName: "MainSwarm",
+ *   defaultAgent: "WeatherAgent",
+ *   policies: ["ContentFilter"],
+ * });
+ * // Logs the operation (if enabled) and updates the swarm schema in the swarm system.
+ */
+const overrideSwarm = beginContext((swarmSchema) => {
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
+        swarm$1.loggerService.log(METHOD_NAME$Q, {
+            swarmSchema,
+        });
+    return swarm$1.swarmSchemaService.override(swarmSchema.swarmName, swarmSchema);
+});
+
+const METHOD_NAME$P = "function.test.overrideTool";
+/**
+ * Overrides an existing tool schema in the swarm system with a new or partial schema.
+ * This function updates the configuration of a tool identified by its `toolName`, applying the provided schema properties.
+ * It operates outside any existing method or execution contexts to ensure isolation, leveraging `beginContext` for a clean execution scope.
+ * Logs the override operation if logging is enabled in the global configuration.
+ *
+ * @param {TAgentTool} toolSchema - The schema containing the tool’s unique name and optional properties to override.
+ * @param {string} toolSchema.toolName - The unique identifier of the tool to override, matching `IAgentTool["toolName"]`.
+ * @param {Partial<IAgentTool>} [toolSchema] - Optional partial schema properties to update, extending `IAgentTool`.
+ * @returns {void} No return value; the override is applied directly to the swarm’s tool schema service.
+ * @throws {Error} If the tool schema service encounters an error during the override operation (e.g., invalid toolName or schema).
+ *
+ * @example
+ * // Override a tool’s schema with new properties
+ * overrideTool({
+ *   toolName: "WeatherTool",
+ *   description: "Updated weather data retrieval tool",
+ *   execute: async (params) => fetchWeather(params),
+ * });
+ * // Logs the operation (if enabled) and updates the tool schema in the swarm.
+ */
+const overrideTool = beginContext((toolSchema) => {
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
+        swarm$1.loggerService.log(METHOD_NAME$P, {
+            toolSchema,
+        });
+    return swarm$1.toolSchemaService.override(toolSchema.toolName, toolSchema);
+});
+
+const METHOD_NAME$O = "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.
+ * It operates outside any existing method or execution contexts to ensure isolation, leveraging `beginContext` for a clean execution scope.
+ * Logs the override operation if logging is enabled in the global configuration.
+ *
+ * @param {TWikiSchema} wikiSchema - The schema containing the wiki’s unique name and optional properties to override.
+ * @param {string} wikiSchema.wikiName - The unique identifier of the wiki to override, matching `IWikiSchema["wikiName"]`.
+ * @param {Partial<IWikiSchema>} [wikiSchema] - Optional partial schema properties to update, extending `IWikiSchema`.
+ * @returns {void} No return value; the override is applied directly to the swarm’s wiki schema service.
+ * @throws {Error} If the wiki schema service encounters an error during the override operation (e.g., invalid wikiName or schema).
+ *
+ * @example
+ * // Override a wiki’s schema with new properties
+ * overrideWiki({
+ *   wikiName: "KnowledgeBase",
+ *   description: "Updated knowledge repository",
+ *   storage: "WikiStorage",
+ * });
+ * // Logs the operation (if enabled) and updates the wiki schema in the swarm.
+ */
+const overrideWiki = beginContext((wikiSchema) => {
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
+        swarm$1.loggerService.log(METHOD_NAME$O, {
+            wikiSchema,
+        });
+    return swarm$1.wikiSchemaService.override(wikiSchema.wikiName, wikiSchema);
+});
+
 const METHOD_NAME$N = "function.other.markOnline";
 /**
  * Marks a client as online in the specified swarm.
@@ -17228,7 +17636,7 @@ const CHANGE_AGENT_GC$2 = 60 * 1000;
  */
 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 circular route found clientId=${clientId} swarmName=${swarmName} agentNameTo=${agentName}`);
+        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
@@ -19595,6 +20003,15 @@ exports.markOffline = markOffline;
 exports.markOnline = markOnline;
 exports.notify = notify;
 exports.notifyForce = notifyForce;
+exports.overrideAgent = overrideAgent;
+exports.overrideCompletion = overrideCompletion;
+exports.overrideEmbeding = overrideEmbeding;
+exports.overridePolicy = overridePolicy;
+exports.overrideState = overrideState;
+exports.overrideStorage = overrideStorage;
+exports.overrideSwarm = overrideSwarm;
+exports.overrideTool = overrideTool;
+exports.overrideWiki = overrideWiki;
 exports.question = question;
 exports.questionForce = questionForce;
 exports.runStateless = runStateless;