agent-swarm-kit 1.1.40 → 1.1.42

package/build/index.cjs

@@ -42,6 +42,7 @@ const contextServices$1 = {
     methodContextService: Symbol('methodContextService'),
     payloadContextService: Symbol('payloadContextService'),
     executionContextService: Symbol('executionContextService'),
+    schemaContextService: Symbol('schemaContextService'),
 };
 const connectionServices$1 = {
     agentConnectionService: Symbol('agentConnectionService'),
@@ -3346,6 +3347,24 @@ class LoggerService {
     }
 }
 
+/**
+ * @module SchemaContextService
+ * @description Defines a service for managing schema context with a registry of schema services, using dependency injection for scoped instantiation.
+ */
+/**
+ * @class SchemaContextService
+ * @description A scoped service that holds the schema context, enabling dependency injection for schema registries.
+ */
+const SchemaContextService = diScoped.scoped(class {
+    /**
+     * @constructor
+     * @param {ISchemaContext} context - The schema context containing the registry of schema services.
+     */
+    constructor(context) {
+        this.context = context;
+    }
+});
+
 /**
  * Service class for managing agent schemas in the swarm system.
  * Provides a centralized registry for storing and retrieving IAgentSchema instances using ToolRegistry from functools-kit, with shallow validation to ensure schema integrity.
@@ -3362,6 +3381,13 @@ class AgentSchemaService {
          * @readonly
          */
         this.loggerService = inject(TYPES.loggerService);
+        /**
+         * Schema context service instance, injected via DI, for managing schema-related context operations.
+         * Provides utilities and methods to interact with schema contexts, supporting schema validation, retrieval, and updates.
+         * @type {TSchemaContextService}
+         * @readonly
+         */
+        this.schemaContextService = inject(TYPES.schemaContextService);
         /**
          * Registry instance for storing agent schemas, initialized with ToolRegistry from functools-kit.
          * Maps AgentName keys to IAgentSchema values, providing efficient storage and retrieval, used in register and get methods.
@@ -3369,7 +3395,7 @@ class AgentSchemaService {
          * @type {ToolRegistry<Record<AgentName, IAgentSchema>>}
          * @private
          */
-        this.registry = new functoolsKit.ToolRegistry("agentSchemaService");
+        this._registry = new functoolsKit.ToolRegistry("agentSchemaService");
         /**
          * Validates an agent schema shallowly, ensuring required fields and array properties meet basic integrity constraints.
          * Checks agentName, completion, and prompt as strings; ensures system, dependsOn, states, storages, and tools are arrays of unique strings if present.
@@ -3508,6 +3534,35 @@ class AgentSchemaService {
             return this.registry.get(key);
         };
     }
+    /**
+     * Retrieves the current registry instance for agent schemas.
+     * If a schema context is available via `SchemaContextService`, it returns the registry from the context.
+     * Otherwise, it falls back to the private `_registry` instance.
+     *
+     * @private
+     * @returns {ToolRegistry<Record<AgentName, IAgentSchema>>} The current registry instance for managing agent schemas.
+     */
+    get registry() {
+        if (SchemaContextService.hasContext()) {
+            return this.schemaContextService.context.registry.agentSchemaService;
+        }
+        return this._registry;
+    }
+    /**
+     * Sets the registry instance for agent schemas.
+     * If a schema context is available via `SchemaContextService`, it updates the registry in the context.
+     * Otherwise, it updates the private `_registry` instance.
+     *
+     * @private
+     * @param {ToolRegistry<Record<AgentName, IAgentSchema>>} value - The new registry instance to set for managing agent schemas.
+     */
+    set registry(value) {
+        if (SchemaContextService.hasContext()) {
+            this.schemaContextService.context.registry.agentSchemaService = value;
+            return;
+        }
+        this._registry = value;
+    }
 }
 
 const AGENT_CHANGE_SYMBOL = Symbol("agent-change");
@@ -4675,7 +4730,7 @@ class ClientOperator {
     }
 }
 
-const METHOD_NAME$1k = "function.commit.commitToolOutput";
+const METHOD_NAME$1l = "function.commit.commitToolOutput";
 /**
  * Commits the output of a tool execution to the active agent in a swarm session.
  *
@@ -4695,19 +4750,19 @@ const METHOD_NAME$1k = "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$1k, {
+        swarm$1.loggerService.log(METHOD_NAME$1l, {
             toolId,
             content,
             clientId,
             agentName,
         });
     // Validate the agent, session, and swarm to ensure they exist and are accessible
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1k);
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1k);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1l);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1l);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1k);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1l);
     // Check if the specified agent is still the active agent in the swarm session
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1k, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1l, clientId, swarmName);
     if (currentAgentName !== agentName) {
         // Log a skip message if the agent has changed during the operation
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
@@ -4720,10 +4775,10 @@ 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$1k, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitToolOutput(toolId, content, METHOD_NAME$1l, clientId, swarmName);
 });
 
-const METHOD_NAME$1j = "function.target.execute";
+const METHOD_NAME$1k = "function.target.execute";
 /**
  * Sends a message to the active agent in a swarm session as if it originated from the client side.
  *
@@ -4745,19 +4800,19 @@ const execute = beginContext(async (content, clientId, agentName) => {
     const executionId = functoolsKit.randomString();
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$1j, {
+        swarm$1.loggerService.log(METHOD_NAME$1k, {
             content,
             clientId,
             agentName,
             executionId,
         });
     // Validate the agent, session, and swarm
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1j);
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1j);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1k);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1k);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1j);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1k);
     // Check if the specified agent is still the active agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1j, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1k, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "execute" skipped due to the agent change', {
@@ -4776,7 +4831,7 @@ const execute = beginContext(async (content, clientId, agentName) => {
                 agentName,
                 swarmName,
             });
-            const result = await swarm$1.sessionPublicService.execute(content, "tool", METHOD_NAME$1j, clientId, swarmName);
+            const result = await swarm$1.sessionPublicService.execute(content, "tool", METHOD_NAME$1k, clientId, swarmName);
             isFinished = swarm$1.perfService.endExecution(executionId, clientId, result.length);
             swarm$1.busService.commitExecutionEnd(clientId, {
                 agentName,
@@ -4797,7 +4852,7 @@ const execute = beginContext(async (content, clientId, agentName) => {
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$1i = "function.commit.commitFlush";
+const METHOD_NAME$1j = "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.
@@ -4814,19 +4869,19 @@ const METHOD_NAME$1i = "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$1i, {
+        swarm$1.loggerService.log(METHOD_NAME$1j, {
             clientId,
             agentName,
         });
     // Validate the agent exists
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1i);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1j);
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1i);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1j);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1i);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1j);
     // Check if the current agent matches the provided agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1i, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1j, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "commitFlush" skipped due to the agent change', {
@@ -4837,10 +4892,10 @@ const commitFlush = beginContext(async (clientId, agentName) => {
         return;
     }
     // Commit the flush of agent history via SessionPublicService
-    await swarm$1.sessionPublicService.commitFlush(METHOD_NAME$1i, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitFlush(METHOD_NAME$1j, clientId, swarmName);
 });
 
-const METHOD_NAME$1h = "function.target.emit";
+const METHOD_NAME$1i = "function.target.emit";
 /**
  * Emits a string as model output without executing an incoming message, with agent activity validation.
  *
@@ -4860,18 +4915,18 @@ const METHOD_NAME$1h = "function.target.emit";
 const emit = beginContext(async (content, clientId, agentName) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$1h, {
+        swarm$1.loggerService.log(METHOD_NAME$1i, {
             content,
             clientId,
             agentName,
         });
     // Validate the agent, session, and swarm
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1h);
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1h);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1i);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1i);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1h);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1i);
     // Check if the specified agent is still the active agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1h, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1i, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "emit" skipped due to the agent change', {
@@ -4882,10 +4937,10 @@ const emit = beginContext(async (content, clientId, agentName) => {
         return;
     }
     // Emit the content directly via the session public service
-    return await swarm$1.sessionPublicService.emit(content, METHOD_NAME$1h, clientId, swarmName);
+    return await swarm$1.sessionPublicService.emit(content, METHOD_NAME$1i, clientId, swarmName);
 });
 
-const METHOD_NAME$1g = "function.common.getAgentName";
+const METHOD_NAME$1h = "function.common.getAgentName";
 /**
  * Retrieves the name of the active agent for a given client session in a swarm.
  *
@@ -4903,19 +4958,19 @@ const METHOD_NAME$1g = "function.common.getAgentName";
 const getAgentName = beginContext(async (clientId) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$1g, {
+        swarm$1.loggerService.log(METHOD_NAME$1h, {
             clientId,
         });
     // Validate the session and swarm to ensure they exist and are accessible
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1g);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1h);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1g);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1h);
     // Retrieve the active agent name via the swarm public service
-    return await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1g, clientId, swarmName);
+    return await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1h, clientId, swarmName);
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$1f = "function.commit.commitStopTools";
+const METHOD_NAME$1g = "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.
@@ -4932,19 +4987,19 @@ const METHOD_NAME$1f = "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$1f, {
+        swarm$1.loggerService.log(METHOD_NAME$1g, {
             clientId,
             agentName,
         });
     // Validate the agent exists
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1f);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1g);
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1f);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1g);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1f);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1g);
     // Check if the current agent matches the provided agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1f, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1g, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "commitStopTools" skipped due to the agent change', {
@@ -4955,7 +5010,7 @@ const commitStopTools = beginContext(async (clientId, agentName) => {
         return;
     }
     // Commit the stop of the next tool execution via SessionPublicService
-    await swarm$1.sessionPublicService.commitStopTools(METHOD_NAME$1f, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitStopTools(METHOD_NAME$1g, clientId, swarmName);
 });
 
 const METHOD_NAME_UPDATE$2 = "McpUtils.update";
@@ -5468,7 +5523,7 @@ class AgentConnectionService {
 }
 
 /** @private Constant defining the method name for logging purposes */
-const METHOD_NAME$1e = "function.common.getPayload";
+const METHOD_NAME$1f = "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.
@@ -5479,7 +5534,7 @@ const METHOD_NAME$1e = "function.common.getPayload";
  * console.log(payload); // { id: number } or null
  */
 const getPayload = () => {
-    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$1e);
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$1f);
     if (PayloadContextService.hasContext()) {
         const { payload } = swarm$1.payloadContextService.context;
         return payload;
@@ -5825,6 +5880,13 @@ class ToolSchemaService {
          * @readonly
          */
         this.loggerService = inject(TYPES.loggerService);
+        /**
+         * Schema context service instance, injected via DI, for managing schema-related context operations.
+         * Provides utilities and methods to interact with schema contexts, supporting schema validation, retrieval, and updates.
+         * @type {TSchemaContextService}
+         * @readonly
+         */
+        this.schemaContextService = inject(TYPES.schemaContextService);
         /**
          * Registry instance for storing tool schemas, initialized with ToolRegistry from functools-kit.
          * Maps ToolName keys to IAgentTool values, providing efficient storage and retrieval, used in register and get methods.
@@ -5832,7 +5894,7 @@ class ToolSchemaService {
          * @type {ToolRegistry<Record<ToolName, IAgentTool>>}
          * @private
          */
-        this.registry = new functoolsKit.ToolRegistry("toolSchemaService");
+        this._registry = new functoolsKit.ToolRegistry("toolSchemaService");
         /**
          * Validates a tool schema shallowly, ensuring required fields meet basic integrity constraints.
          * Checks toolName as a string, call and validate as functions (for tool execution and input validation), and function as an object (tool metadata), using isObject from functools-kit.
@@ -5908,6 +5970,29 @@ class ToolSchemaService {
             };
         };
     }
+    /**
+     * Retrieves the current registry instance for agent schemas.
+     * If a schema context is available via `SchemaContextService`, it returns the registry from the context.
+     * Otherwise, it falls back to the private `_registry` instance.
+     */
+    get registry() {
+        if (SchemaContextService.hasContext()) {
+            return this.schemaContextService.context.registry.toolSchemaService;
+        }
+        return this._registry;
+    }
+    /**
+     * Sets the registry instance for agent schemas.
+     * If a schema context is available via `SchemaContextService`, it updates the registry in the context.
+     * Otherwise, it updates the private `_registry` instance.
+     */
+    set registry(value) {
+        if (SchemaContextService.hasContext()) {
+            this.schemaContextService.context.registry.toolSchemaService = value;
+            return;
+        }
+        this._registry = value;
+    }
 }
 
 const AGENT_NEED_FETCH = Symbol("agent-need-fetch");
@@ -6593,6 +6678,13 @@ class SwarmSchemaService {
          * @readonly
          */
         this.loggerService = inject(TYPES.loggerService);
+        /**
+         * Schema context service instance, injected via DI, for managing schema-related context operations.
+         * Provides utilities and methods to interact with schema contexts, supporting schema validation, retrieval, and updates.
+         * @type {TSchemaContextService}
+         * @readonly
+         */
+        this.schemaContextService = inject(TYPES.schemaContextService);
         /**
          * Registry instance for storing swarm schemas, initialized with ToolRegistry from functools-kit.
          * Maps SwarmName keys to ISwarmSchema values, providing efficient storage and retrieval, used in register and get methods.
@@ -6600,7 +6692,7 @@ class SwarmSchemaService {
          * @type {ToolRegistry<Record<SwarmName, ISwarmSchema>>}
          * @private
          */
-        this.registry = new functoolsKit.ToolRegistry("swarmSchemaService");
+        this._registry = new functoolsKit.ToolRegistry("swarmSchemaService");
         /**
          * Validates a swarm schema shallowly, ensuring required fields and optional properties meet basic integrity constraints.
          * Checks swarmName and defaultAgent as strings, agentList as an array of unique strings (AgentName references), and policies, if present, as an array of unique strings (PolicyName references).
@@ -6685,6 +6777,29 @@ class SwarmSchemaService {
             return this.registry.get(key);
         };
     }
+    /**
+     * Retrieves the current registry instance for agent schemas.
+     * If a schema context is available via `SchemaContextService`, it returns the registry from the context.
+     * Otherwise, it falls back to the private `_registry` instance.
+     */
+    get registry() {
+        if (SchemaContextService.hasContext()) {
+            return this.schemaContextService.context.registry.swarmSchemaService;
+        }
+        return this._registry;
+    }
+    /**
+     * Sets the registry instance for agent schemas.
+     * If a schema context is available via `SchemaContextService`, it updates the registry in the context.
+     * Otherwise, it updates the private `_registry` instance.
+     */
+    set registry(value) {
+        if (SchemaContextService.hasContext()) {
+            this.schemaContextService.context.registry.swarmSchemaService = value;
+            return;
+        }
+        this._registry = value;
+    }
 }
 
 /**
@@ -6703,6 +6818,13 @@ class CompletionSchemaService {
          * @readonly
          */
         this.loggerService = inject(TYPES.loggerService);
+        /**
+         * Schema context service instance, injected via DI, for managing schema-related context operations.
+         * Provides utilities and methods to interact with schema contexts, supporting schema validation, retrieval, and updates.
+         * @type {TSchemaContextService}
+         * @readonly
+         */
+        this.schemaContextService = inject(TYPES.schemaContextService);
         /**
          * Registry instance for storing completion schemas, initialized with ToolRegistry from functools-kit.
          * Maps CompletionName keys to ICompletionSchema values, providing efficient storage and retrieval, used in register and get methods.
@@ -6710,7 +6832,7 @@ class CompletionSchemaService {
          * @type {ToolRegistry<Record<CompletionName, ICompletionSchema>>}
          * @private
          */
-        this.registry = new functoolsKit.ToolRegistry("completionSchemaService");
+        this._registry = new functoolsKit.ToolRegistry("completionSchemaService");
         /**
          * Validates a completion schema shallowly, ensuring required fields meet basic integrity constraints.
          * Checks completionName as a string and getCompletion as a function, critical for agent execution in ClientAgent.
@@ -6776,6 +6898,30 @@ class CompletionSchemaService {
             return this.registry.get(key);
         };
     }
+    /**
+     * Retrieves the current registry instance for agent schemas.
+     * If a schema context is available via `SchemaContextService`, it returns the registry from the context.
+     * Otherwise, it falls back to the private `_registry` instance.
+     */
+    get registry() {
+        if (SchemaContextService.hasContext()) {
+            return this.schemaContextService.context.registry.completionSchemaService;
+        }
+        return this._registry;
+    }
+    /**
+     * Sets the registry instance for agent schemas.
+     * If a schema context is available via `SchemaContextService`, it updates the registry in the context.
+     * Otherwise, it updates the private `_registry` instance.
+     */
+    set registry(value) {
+        if (SchemaContextService.hasContext()) {
+            this.schemaContextService.context.registry.completionSchemaService =
+                value;
+            return;
+        }
+        this._registry = value;
+    }
 }
 
 /**
@@ -10096,6 +10242,13 @@ class EmbeddingSchemaService {
          * @readonly
          */
         this.loggerService = inject(TYPES.loggerService);
+        /**
+         * Schema context service instance, injected via DI, for managing schema-related context operations.
+         * Provides utilities and methods to interact with schema contexts, supporting schema validation, retrieval, and updates.
+         * @type {TSchemaContextService}
+         * @readonly
+         */
+        this.schemaContextService = inject(TYPES.schemaContextService);
         /**
          * Registry instance for storing embedding schemas, initialized with ToolRegistry from functools-kit.
          * Maps EmbeddingName keys to IEmbeddingSchema values, providing efficient storage and retrieval, used in register and get methods.
@@ -10103,7 +10256,7 @@ class EmbeddingSchemaService {
          * @type {ToolRegistry<Record<EmbeddingName, IEmbeddingSchema>>}
          * @private
          */
-        this.registry = new functoolsKit.ToolRegistry("embeddingSchemaService");
+        this._registry = new functoolsKit.ToolRegistry("embeddingSchemaService");
         /**
          * Validates an embedding schema shallowly, ensuring required fields meet basic integrity constraints.
          * Checks embeddingName as a string and calculateSimilarity and createEmbedding as functions, critical for storage operations in StorageConnectionService and SharedStorageConnectionService.
@@ -10172,6 +10325,29 @@ class EmbeddingSchemaService {
             return this.registry.get(key);
         };
     }
+    /**
+     * Retrieves the current registry instance for agent schemas.
+     * If a schema context is available via `SchemaContextService`, it returns the registry from the context.
+     * Otherwise, it falls back to the private `_registry` instance.
+     */
+    get registry() {
+        if (SchemaContextService.hasContext()) {
+            return this.schemaContextService.context.registry.embeddingSchemaService;
+        }
+        return this._registry;
+    }
+    /**
+     * Sets the registry instance for agent schemas.
+     * If a schema context is available via `SchemaContextService`, it updates the registry in the context.
+     * Otherwise, it updates the private `_registry` instance.
+     */
+    set registry(value) {
+        if (SchemaContextService.hasContext()) {
+            this.schemaContextService.context.registry.embeddingSchemaService = value;
+            return;
+        }
+        this._registry = value;
+    }
 }
 
 /**
@@ -10190,6 +10366,13 @@ class StorageSchemaService {
          * @readonly
          */
         this.loggerService = inject(TYPES.loggerService);
+        /**
+         * Schema context service instance, injected via DI, for managing schema-related context operations.
+         * Provides utilities and methods to interact with schema contexts, supporting schema validation, retrieval, and updates.
+         * @type {TSchemaContextService}
+         * @readonly
+         */
+        this.schemaContextService = inject(TYPES.schemaContextService);
         /**
          * Registry instance for storing storage schemas, initialized with ToolRegistry from functools-kit.
          * Maps StorageName keys to IStorageSchema values, providing efficient storage and retrieval, used in register and get methods.
@@ -10197,7 +10380,7 @@ class StorageSchemaService {
          * @type {ToolRegistry<Record<StorageName, IStorageSchema>>}
          * @private
          */
-        this.registry = new functoolsKit.ToolRegistry("storageSchemaService");
+        this._registry = new functoolsKit.ToolRegistry("storageSchemaService");
         /**
          * Validates a storage schema shallowly, ensuring required fields meet basic integrity constraints.
          * Checks storageName as a string, createIndex as a function (for indexing storage data), and embedding as a string (referencing an EmbeddingName from EmbeddingSchemaService).
@@ -10266,6 +10449,29 @@ class StorageSchemaService {
             return this.registry.get(key);
         };
     }
+    /**
+     * Retrieves the current registry instance for agent schemas.
+     * If a schema context is available via `SchemaContextService`, it returns the registry from the context.
+     * Otherwise, it falls back to the private `_registry` instance.
+     */
+    get registry() {
+        if (SchemaContextService.hasContext()) {
+            return this.schemaContextService.context.registry.storageSchemaService;
+        }
+        return this._registry;
+    }
+    /**
+     * Sets the registry instance for agent schemas.
+     * If a schema context is available via `SchemaContextService`, it updates the registry in the context.
+     * Otherwise, it updates the private `_registry` instance.
+     */
+    set registry(value) {
+        if (SchemaContextService.hasContext()) {
+            this.schemaContextService.context.registry.storageSchemaService = value;
+            return;
+        }
+        this._registry = value;
+    }
 }
 
 const STORAGE_POOL_DELAY = 0;
@@ -11340,6 +11546,13 @@ class StateSchemaService {
          * @readonly
          */
         this.loggerService = inject(TYPES.loggerService);
+        /**
+         * Schema context service instance, injected via DI, for managing schema-related context operations.
+         * Provides utilities and methods to interact with schema contexts, supporting schema validation, retrieval, and updates.
+         * @type {TSchemaContextService}
+         * @readonly
+         */
+        this.schemaContextService = inject(TYPES.schemaContextService);
         /**
          * Registry instance for storing state schemas, initialized with ToolRegistry from functools-kit.
          * Maps StateName keys to IStateSchema values, providing efficient storage and retrieval, used in register and get methods.
@@ -11347,7 +11560,7 @@ class StateSchemaService {
          * @type {ToolRegistry<Record<StateName, IStateSchema>>}
          * @private
          */
-        this.registry = new functoolsKit.ToolRegistry("stateSchemaService");
+        this._registry = new functoolsKit.ToolRegistry("stateSchemaService");
         /**
          * Validates a state schema shallowly, ensuring required fields and optional properties meet basic integrity constraints.
          * Checks stateName as a string and getState as a function (required for state retrieval), and ensures middlewares, if present, is an array of functions.
@@ -11419,6 +11632,29 @@ class StateSchemaService {
             return this.registry.get(key);
         };
     }
+    /**
+     * Retrieves the current registry instance for agent schemas.
+     * If a schema context is available via `SchemaContextService`, it returns the registry from the context.
+     * Otherwise, it falls back to the private `_registry` instance.
+     */
+    get registry() {
+        if (SchemaContextService.hasContext()) {
+            return this.schemaContextService.context.registry.stateSchemaService;
+        }
+        return this._registry;
+    }
+    /**
+     * Sets the registry instance for agent schemas.
+     * If a schema context is available via `SchemaContextService`, it updates the registry in the context.
+     * Otherwise, it updates the private `_registry` instance.
+     */
+    set registry(value) {
+        if (SchemaContextService.hasContext()) {
+            this.schemaContextService.context.registry.stateSchemaService = value;
+            return;
+        }
+        this._registry = value;
+    }
 }
 
 /**
@@ -14251,6 +14487,13 @@ class PolicySchemaService {
          * @readonly
          */
         this.loggerService = inject(TYPES.loggerService);
+        /**
+         * Schema context service instance, injected via DI, for managing schema-related context operations.
+         * Provides utilities and methods to interact with schema contexts, supporting schema validation, retrieval, and updates.
+         * @type {TSchemaContextService}
+         * @readonly
+         */
+        this.schemaContextService = inject(TYPES.schemaContextService);
         /**
          * Registry instance for storing policy schemas, initialized with ToolRegistry from functools-kit.
          * Maps PolicyName keys to IPolicySchema values, providing efficient storage and retrieval, used in register and get methods.
@@ -14258,7 +14501,7 @@ class PolicySchemaService {
          * @type {ToolRegistry<Record<PolicyName, IPolicySchema>>}
          * @private
          */
-        this.registry = new functoolsKit.ToolRegistry("policySchemaService");
+        this._registry = new functoolsKit.ToolRegistry("policySchemaService");
         /**
          * Validates a policy schema shallowly, ensuring required fields meet basic integrity constraints.
          * Checks policyName as a string and getBannedClients as a function, critical for policy enforcement in PolicyConnectionService.
@@ -14325,6 +14568,29 @@ class PolicySchemaService {
             return this.registry.get(key);
         };
     }
+    /**
+     * Retrieves the current registry instance for agent schemas.
+     * If a schema context is available via `SchemaContextService`, it returns the registry from the context.
+     * Otherwise, it falls back to the private `_registry` instance.
+     */
+    get registry() {
+        if (SchemaContextService.hasContext()) {
+            return this.schemaContextService.context.registry.policySchemaService;
+        }
+        return this._registry;
+    }
+    /**
+     * Sets the registry instance for agent schemas.
+     * If a schema context is available via `SchemaContextService`, it updates the registry in the context.
+     * Otherwise, it updates the private `_registry` instance.
+     */
+    set registry(value) {
+        if (SchemaContextService.hasContext()) {
+            this.schemaContextService.context.registry.policySchemaService = value;
+            return;
+        }
+        this._registry = value;
+    }
 }
 
 /**
@@ -15201,11 +15467,18 @@ class WikiSchemaService {
          * @description Injected logger service instance
          */
         this.loggerService = inject(TYPES.loggerService);
+        /**
+         * Schema context service instance, injected via DI, for managing schema-related context operations.
+         * Provides utilities and methods to interact with schema contexts, supporting schema validation, retrieval, and updates.
+         * @type {TSchemaContextService}
+         * @readonly
+         */
+        this.schemaContextService = inject(TYPES.schemaContextService);
         /**
          * @private
          * @description Registry for storing wiki schemas
          */
-        this.registry = new functoolsKit.ToolRegistry("wikiSchemaService");
+        this._registry = new functoolsKit.ToolRegistry("wikiSchemaService");
         /**
          * Validates basic requirements of a wiki schema
          * @private
@@ -15261,6 +15534,29 @@ class WikiSchemaService {
             return this.registry.get(key);
         };
     }
+    /**
+     * Retrieves the current registry instance for agent schemas.
+     * If a schema context is available via `SchemaContextService`, it returns the registry from the context.
+     * Otherwise, it falls back to the private `_registry` instance.
+     */
+    get registry() {
+        if (SchemaContextService.hasContext()) {
+            return this.schemaContextService.context.registry.wikiSchemaService;
+        }
+        return this._registry;
+    }
+    /**
+     * Sets the registry instance for agent schemas.
+     * If a schema context is available via `SchemaContextService`, it updates the registry in the context.
+     * Otherwise, it updates the private `_registry` instance.
+     */
+    set registry(value) {
+        if (SchemaContextService.hasContext()) {
+            this.schemaContextService.context.registry.wikiSchemaService = value;
+            return;
+        }
+        this._registry = value;
+    }
 }
 
 /**
@@ -15554,8 +15850,15 @@ class MCPSchemaService {
     constructor() {
         /** Injected LoggerService for logging operations. */
         this.loggerService = inject(TYPES.loggerService);
+        /**
+         * Schema context service instance, injected via DI, for managing schema-related context operations.
+         * Provides utilities and methods to interact with schema contexts, supporting schema validation, retrieval, and updates.
+         * @type {TSchemaContextService}
+         * @readonly
+         */
+        this.schemaContextService = inject(TYPES.schemaContextService);
         /** Registry for storing MCP schemas, keyed by MCP name. */
-        this.registry = new functoolsKit.ToolRegistry("mcpSchemaService");
+        this._registry = new functoolsKit.ToolRegistry("mcpSchemaService");
         /**
          * Validates the basic structure of an MCP schema.
          * @param mcpSchema - The MCP schema to validate.
@@ -15610,6 +15913,29 @@ class MCPSchemaService {
             return this.registry.get(key);
         };
     }
+    /**
+     * Retrieves the current registry instance for agent schemas.
+     * If a schema context is available via `SchemaContextService`, it returns the registry from the context.
+     * Otherwise, it falls back to the private `_registry` instance.
+     */
+    get registry() {
+        if (SchemaContextService.hasContext()) {
+            return this.schemaContextService.context.registry.mcpSchemaService;
+        }
+        return this._registry;
+    }
+    /**
+     * Sets the registry instance for agent schemas.
+     * If a schema context is available via `SchemaContextService`, it updates the registry in the context.
+     * Otherwise, it updates the private `_registry` instance.
+     */
+    set registry(value) {
+        if (SchemaContextService.hasContext()) {
+            this.schemaContextService.context.registry.mcpSchemaService = value;
+            return;
+        }
+        this._registry = value;
+    }
 }
 
 /**
@@ -15846,12 +16172,19 @@ class ComputeSchemaService {
          * @readonly
          */
         this.loggerService = inject(TYPES.loggerService);
+        /**
+         * Schema context service instance, injected via DI, for managing schema-related context operations.
+         * Provides utilities and methods to interact with schema contexts, supporting schema validation, retrieval, and updates.
+         * @type {TSchemaContextService}
+         * @readonly
+         */
+        this.schemaContextService = inject(TYPES.schemaContextService);
         /**
          * @property {ToolRegistry<Record<ComputeName, IComputeSchema>>} registry
          * @description Registry for storing compute schemas.
          * @private
          */
-        this.registry = new functoolsKit.ToolRegistry("computeSchemaService");
+        this._registry = new functoolsKit.ToolRegistry("computeSchemaService");
         /**
          * @method validateShallow
          * @description Performs shallow validation of a compute schema.
@@ -15873,7 +16206,8 @@ class ComputeSchemaService {
             if (typeof computeSchema.getComputeData !== "function") {
                 throw new Error(`agent-swarm compute schema validation failed: missing getComputeData for computeName=${computeSchema.computeName}`);
             }
-            if (computeSchema.middlewares && !Array.isArray(computeSchema.middlewares)) {
+            if (computeSchema.middlewares &&
+                !Array.isArray(computeSchema.middlewares)) {
                 throw new Error(`agent-swarm compute schema validation failed: invalid middlewares for computeName=${computeSchema.computeName} middlewares=${computeSchema.middlewares}`);
             }
             if (computeSchema.middlewares?.some((value) => typeof value !== "function")) {
@@ -15923,6 +16257,29 @@ class ComputeSchemaService {
             return this.registry.get(key);
         };
     }
+    /**
+     * Retrieves the current registry instance for agent schemas.
+     * If a schema context is available via `SchemaContextService`, it returns the registry from the context.
+     * Otherwise, it falls back to the private `_registry` instance.
+     */
+    get registry() {
+        if (SchemaContextService.hasContext()) {
+            return this.schemaContextService.context.registry.computeSchemaService;
+        }
+        return this._registry;
+    }
+    /**
+     * Sets the registry instance for agent schemas.
+     * If a schema context is available via `SchemaContextService`, it updates the registry in the context.
+     * Otherwise, it updates the private `_registry` instance.
+     */
+    set registry(value) {
+        if (SchemaContextService.hasContext()) {
+            this.schemaContextService.context.registry.computeSchemaService = value;
+            return;
+        }
+        this._registry = value;
+    }
 }
 
 /**
@@ -16745,12 +17102,19 @@ class PipelineSchemaService {
          * @private
          */
         this.loggerService = inject(TYPES.loggerService);
+        /**
+         * Schema context service instance, injected via DI, for managing schema-related context operations.
+         * Provides utilities and methods to interact with schema contexts, supporting schema validation, retrieval, and updates.
+         * @type {TSchemaContextService}
+         * @readonly
+         */
+        this.schemaContextService = inject(TYPES.schemaContextService);
         /**
          * @property {ToolRegistry<Record<PipelineName, IPipelineSchema>>} registry
          * @description Registry for storing pipeline schemas.
          * @private
          */
-        this.registry = new functoolsKit.ToolRegistry("pipelineSchemaService");
+        this._registry = new functoolsKit.ToolRegistry("pipelineSchemaService");
         /**
          * @method validateShallow
          * @description Performs shallow validation of a pipeline schema.
@@ -16807,6 +17171,29 @@ class PipelineSchemaService {
             return this.registry.get(key);
         };
     }
+    /**
+     * Retrieves the current registry instance for agent schemas.
+     * If a schema context is available via `SchemaContextService`, it returns the registry from the context.
+     * Otherwise, it falls back to the private `_registry` instance.
+     */
+    get registry() {
+        if (SchemaContextService.hasContext()) {
+            return this.schemaContextService.context.registry.pipelineSchemaService;
+        }
+        return this._registry;
+    }
+    /**
+     * Sets the registry instance for agent schemas.
+     * If a schema context is available via `SchemaContextService`, it updates the registry in the context.
+     * Otherwise, it updates the private `_registry` instance.
+     */
+    set registry(value) {
+        if (SchemaContextService.hasContext()) {
+            this.schemaContextService.context.registry.pipelineSchemaService = value;
+            return;
+        }
+        this._registry = value;
+    }
 }
 
 /**
@@ -16880,6 +17267,7 @@ class PipelineValidationService {
     provide(TYPES.methodContextService, () => new MethodContextService());
     provide(TYPES.payloadContextService, () => new PayloadContextService());
     provide(TYPES.executionContextService, () => new ExecutionContextService());
+    provide(TYPES.schemaContextService, () => new SchemaContextService());
 }
 {
     provide(TYPES.agentConnectionService, () => new AgentConnectionService());
@@ -16956,6 +17344,7 @@ const contextServices = {
     methodContextService: inject(TYPES.methodContextService),
     payloadContextService: inject(TYPES.payloadContextService),
     executionContextService: inject(TYPES.executionContextService),
+    schemaContextService: inject(TYPES.schemaContextService),
 };
 const connectionServices = {
     agentConnectionService: inject(TYPES.agentConnectionService),
@@ -17033,7 +17422,7 @@ const swarm = {
 init();
 var swarm$1 = swarm;
 
-const METHOD_NAME$1d = "cli.dumpDocs";
+const METHOD_NAME$1e = "cli.dumpDocs";
 /**
  * Dumps the documentation for the agents and swarms.
  *
@@ -17043,7 +17432,7 @@ const METHOD_NAME$1d = "cli.dumpDocs";
  */
 const dumpDocs = beginContext((prefix = "swarm", dirName = "./docs/chat", PlantUML) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$1d, {
+        swarm$1.loggerService.log(METHOD_NAME$1e, {
             dirName,
         });
     if (PlantUML) {
@@ -17053,10 +17442,10 @@ const dumpDocs = beginContext((prefix = "swarm", dirName = "./docs/chat", PlantU
     }
     swarm$1.agentValidationService
         .getAgentList()
-        .forEach((agentName) => swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1d));
+        .forEach((agentName) => swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1e));
     swarm$1.swarmValidationService
         .getSwarmList()
-        .forEach((swarmName) => swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1d));
+        .forEach((swarmName) => swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1e));
     swarm$1.agentValidationService.getAgentList().forEach((agentName) => {
         const { dependsOn } = swarm$1.agentSchemaService.get(agentName);
         if (!dependsOn) {
@@ -17066,7 +17455,7 @@ const dumpDocs = beginContext((prefix = "swarm", dirName = "./docs/chat", PlantU
     return swarm$1.docService.dumpDocs(prefix, dirName);
 });
 
-const METHOD_NAME$1c = "cli.dumpAgent";
+const METHOD_NAME$1d = "cli.dumpAgent";
 /**
  * Dumps the agent information into PlantUML format.
  *
@@ -17075,14 +17464,14 @@ const METHOD_NAME$1c = "cli.dumpAgent";
  */
 const dumpAgent = beginContext((agentName, { withSubtree = false } = {}) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$1c, {
+        swarm$1.loggerService.log(METHOD_NAME$1d, {
             agentName,
         });
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1c);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1d);
     return swarm$1.agentMetaService.toUML(agentName, withSubtree);
 });
 
-const METHOD_NAME$1b = "cli.dumpSwarm";
+const METHOD_NAME$1c = "cli.dumpSwarm";
 /**
  * Dumps the swarm information into PlantUML format.
  *
@@ -17091,14 +17480,14 @@ const METHOD_NAME$1b = "cli.dumpSwarm";
  */
 const dumpSwarm = beginContext((swarmName) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$1b, {
+        swarm$1.loggerService.log(METHOD_NAME$1c, {
             swarmName,
         });
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1b);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1c);
     return swarm$1.swarmMetaService.toUML(swarmName);
 });
 
-const METHOD_NAME$1a = "cli.dumpPerfomance";
+const METHOD_NAME$1b = "cli.dumpPerfomance";
 const METHOD_NAME_INTERNAL$1 = "cli.dumpPerfomance.internal";
 const METHOD_NAME_INTERVAL = "cli.dumpPerfomance.interval";
 /**
@@ -17117,7 +17506,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$1a);
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$1b);
     await dumpPerfomanceInternal(dirName);
 };
 /**
@@ -17175,7 +17564,7 @@ const listenExecutionEvent = beginContext((clientId, fn) => {
     return swarm$1.busService.subscribe(clientId, "execution-bus", functoolsKit.queued(async (e) => await fn(e)));
 });
 
-const METHOD_NAME$19 = "cli.dumpClientPerformance";
+const METHOD_NAME$1a = "cli.dumpClientPerformance";
 const METHOD_NAME_INTERNAL = "cli.dumpClientPerformance.internal";
 const METHOD_NAME_EXECUTE = "cli.dumpClientPerformance.execute";
 /**
@@ -17199,7 +17588,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$19);
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$1a);
     await dumpClientPerformanceInternal(clientId, dirName);
 };
 /**
@@ -17220,7 +17609,7 @@ dumpClientPerformance.runAfterExecute = beginContext(async (dirName = "./logs/cl
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$18 = "function.commit.commitFlushForce";
+const METHOD_NAME$19 = "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.
@@ -17238,20 +17627,20 @@ const METHOD_NAME$18 = "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$18, {
+        swarm$1.loggerService.log(METHOD_NAME$19, {
             clientId,
-            METHOD_NAME: METHOD_NAME$18,
+            METHOD_NAME: METHOD_NAME$19,
         });
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$18);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$19);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$18);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$19);
     // Commit the flush of agent history via SessionPublicService without agent checks
-    await swarm$1.sessionPublicService.commitFlush(METHOD_NAME$18, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitFlush(METHOD_NAME$19, clientId, swarmName);
 });
 
-const METHOD_NAME$17 = "function.commit.commitToolOutputForce";
+const METHOD_NAME$18 = "function.commit.commitToolOutputForce";
 /**
  * Commits the output of a tool execution to the active agent in a swarm session without checking the active agent.
  *
@@ -17270,24 +17659,24 @@ const METHOD_NAME$17 = "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$17, {
+        swarm$1.loggerService.log(METHOD_NAME$18, {
             toolId,
             content,
             clientId,
         });
     // Validate the session and swarm to ensure they exist and are accessible
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$17);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$18);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$17);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$18);
     // 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$17, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitToolOutput(toolId, content, METHOD_NAME$18, clientId, swarmName);
 });
 
 /**
  * @private Constant defining the method name for logging and validation purposes.
  * Used as an identifier in log messages and validation checks to track calls to `hasNavigation`.
  */
-const METHOD_NAME$16 = "function.common.hasNavigation";
+const METHOD_NAME$17 = "function.common.hasNavigation";
 /**
  * Checks if a specific agent is part of the navigation route for a given client.
  * Validates the agent and client session, retrieves the associated swarm, and queries the navigation route.
@@ -17298,16 +17687,16 @@ const METHOD_NAME$16 = "function.common.hasNavigation";
  */
 const hasNavigation = async (clientId, agentName) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$16, { clientId });
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$16);
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$16);
+        swarm$1.loggerService.log(METHOD_NAME$17, { clientId });
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$17);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$17);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     return swarm$1.navigationValidationService
         .getNavigationRoute(clientId, swarmName)
         .has(agentName);
 };
 
-const METHOD_NAME$15 = "function.history.getRawHistory";
+const METHOD_NAME$16 = "function.history.getRawHistory";
 /**
  * Retrieves the raw, unmodified history for a given client session.
  *
@@ -17324,10 +17713,10 @@ const METHOD_NAME$15 = "function.history.getRawHistory";
  * const rawHistory = await getRawHistory("client-123");
  * console.log(rawHistory); // Outputs the full raw history array
  */
-const getRawHistory = beginContext(async (clientId, methodName = METHOD_NAME$15) => {
+const getRawHistory = beginContext(async (clientId, methodName = METHOD_NAME$16) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$15, {
+        swarm$1.loggerService.log(METHOD_NAME$16, {
             clientId,
         });
     // Validate the session and swarm
@@ -17340,7 +17729,7 @@ const getRawHistory = beginContext(async (clientId, methodName = METHOD_NAME$15)
     return [...history];
 });
 
-const METHOD_NAME$14 = "function.history.getLastUserMessage";
+const METHOD_NAME$15 = "function.history.getLastUserMessage";
 /**
  * Retrieves the content of the most recent user message from a client's session history.
  *
@@ -17358,18 +17747,18 @@ const METHOD_NAME$14 = "function.history.getLastUserMessage";
 const getLastUserMessage = beginContext(async (clientId) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$14, {
+        swarm$1.loggerService.log(METHOD_NAME$15, {
             clientId,
         });
     // Fetch raw history and find the last user message
-    const history = await getRawHistory(clientId, METHOD_NAME$14);
+    const history = await getRawHistory(clientId, METHOD_NAME$15);
     const last = history.findLast(({ role, mode }) => role === "user" && mode === "user");
     return last?.content ? last.content : null;
 });
 
 const disposeSubject = new functoolsKit.Subject();
 
-const METHOD_NAME$13 = "function.navigate.changeToDefaultAgent";
+const METHOD_NAME$14 = "function.navigate.changeToDefaultAgent";
 /**
  * Creates a change agent function with time-to-live (TTL) and queuing capabilities for switching to the default agent.
  *
@@ -17392,7 +17781,7 @@ const createChangeToDefaultAgent = functoolsKit.memoize(([clientId]) => `${clien
     }));
     {
         // Dispose of the current agent's resources and set up the new default agent
-        const agentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$13, clientId, swarmName);
+        const agentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$14, clientId, swarmName);
         await swarm$1.agentPublicService.dispose(methodName, clientId, agentName);
         await swarm$1.historyPublicService.dispose(methodName, clientId, agentName);
         await swarm$1.swarmPublicService.setAgentRef(methodName, clientId, swarmName, agentName, await swarm$1.agentPublicService.createAgentRef(methodName, clientId, agentName));
@@ -17430,23 +17819,23 @@ const createGc$3 = functoolsKit.singleshot(async () => {
 const changeToDefaultAgent = beginContext(async (clientId) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$13, {
+        swarm$1.loggerService.log(METHOD_NAME$14, {
             clientId,
         });
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     const { defaultAgent: agentName } = swarm$1.swarmSchemaService.get(swarmName);
     {
         // Validate session and default agent
-        swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$13);
-        swarm$1.agentValidationService.validate(agentName, METHOD_NAME$13);
+        swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$14);
+        swarm$1.agentValidationService.validate(agentName, METHOD_NAME$14);
     }
     // Execute the agent change with TTL and queuing
     const run = await createChangeToDefaultAgent(clientId);
     createGc$3();
-    return await run(METHOD_NAME$13, agentName, swarmName);
+    return await run(METHOD_NAME$14, agentName, swarmName);
 });
 
-const METHOD_NAME$12 = "function.target.emitForce";
+const METHOD_NAME$13 = "function.target.emitForce";
 /**
  * Emits a string as model output without executing an incoming message or checking the active agent.
  *
@@ -17465,19 +17854,19 @@ const METHOD_NAME$12 = "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$12, {
+        swarm$1.loggerService.log(METHOD_NAME$13, {
             content,
             clientId,
         });
     // Validate the session and swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$12);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$13);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$12);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$13);
     // Emit the content directly via the session public service
-    return await swarm$1.sessionPublicService.emit(content, METHOD_NAME$12, clientId, swarmName);
+    return await swarm$1.sessionPublicService.emit(content, METHOD_NAME$13, clientId, swarmName);
 });
 
-const METHOD_NAME$11 = "function.target.executeForce";
+const METHOD_NAME$12 = "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.
  *
@@ -17498,22 +17887,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$11, {
+        swarm$1.loggerService.log(METHOD_NAME$12, {
             content,
             clientId,
             executionId,
         });
     // Validate the session and swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$11);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$12);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$11);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$12);
     // 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$11, clientId, swarmName);
+            const result = await swarm$1.sessionPublicService.execute(content, "tool", METHOD_NAME$12, clientId, swarmName);
             isFinished = swarm$1.perfService.endExecution(executionId, clientId, result.length);
             swarm$1.busService.commitExecutionEnd(clientId, { swarmName });
             return result;
@@ -17530,7 +17919,7 @@ const executeForce = beginContext(async (content, clientId) => {
     });
 });
 
-const METHOD_NAME$10 = "function.template.navigateToTriageAgent";
+const METHOD_NAME$11 = "function.template.navigateToTriageAgent";
 /**
  * Will send tool output directly to the model without any additions
  */
@@ -17581,7 +17970,7 @@ const createNavigateToTriageAgent = ({ flushMessage, lastMessage: lastMessageFn
      */
     return beginContext(async (toolId, clientId) => {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-            swarm$1.loggerService.log(METHOD_NAME$10, {
+            swarm$1.loggerService.log(METHOD_NAME$11, {
                 clientId,
                 toolId,
             });
@@ -17613,7 +18002,7 @@ const createNavigateToTriageAgent = ({ flushMessage, lastMessage: lastMessageFn
     });
 };
 
-const METHOD_NAME$$ = "function.navigate.changeToAgent";
+const METHOD_NAME$10 = "function.navigate.changeToAgent";
 /**
  * Creates a change agent function with time-to-live (TTL) and queuing capabilities.
  *
@@ -17637,7 +18026,7 @@ const createChangeToAgent = functoolsKit.memoize(([clientId]) => `${clientId}`,
     }));
     {
         // Dispose of the current agent's resources and set up the new agent
-        const agentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$$, clientId, swarmName);
+        const agentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$10, clientId, swarmName);
         await swarm$1.agentPublicService.dispose(methodName, clientId, agentName);
         await swarm$1.historyPublicService.dispose(methodName, clientId, agentName);
         await swarm$1.swarmPublicService.setAgentRef(methodName, clientId, swarmName, agentName, await swarm$1.agentPublicService.createAgentRef(methodName, clientId, agentName));
@@ -17676,16 +18065,16 @@ const createGc$2 = functoolsKit.singleshot(async () => {
 const changeToAgent = beginContext(async (agentName, clientId) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$$, {
+        swarm$1.loggerService.log(METHOD_NAME$10, {
             agentName,
             clientId,
         });
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     {
         // Validate session, agent, and dependencies
-        swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$$);
-        swarm$1.agentValidationService.validate(agentName, METHOD_NAME$$);
-        const activeAgent = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$$, clientId, swarmName);
+        swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$10);
+        swarm$1.agentValidationService.validate(agentName, METHOD_NAME$10);
+        const activeAgent = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$10, clientId, swarmName);
         if (!swarm$1.agentValidationService.hasDependency(activeAgent, agentName)) {
             console.error(`agent-swarm missing dependency detected for activeAgent=${activeAgent} dependencyAgent=${agentName}`);
         }
@@ -17703,10 +18092,10 @@ const changeToAgent = beginContext(async (agentName, clientId) => {
     // Execute the agent change with TTL and queuing
     const run = await createChangeToAgent(clientId);
     createGc$2();
-    return await run(METHOD_NAME$$, agentName, swarmName);
+    return await run(METHOD_NAME$10, agentName, swarmName);
 });
 
-const METHOD_NAME$_ = "function.template.navigateToAgent";
+const METHOD_NAME$$ = "function.template.navigateToAgent";
 /**
  * Will send tool output directly to the model without any additions
  */
@@ -17772,7 +18161,7 @@ const createNavigateToAgent = ({ executeMessage = DEFAULT_EXECUTE_MESSAGE, emitM
      */
     return beginContext(async (toolId, clientId, agentName) => {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-            swarm$1.loggerService.log(METHOD_NAME$_, {
+            swarm$1.loggerService.log(METHOD_NAME$$, {
                 clientId,
                 toolId,
             });
@@ -17805,7 +18194,7 @@ const createNavigateToAgent = ({ executeMessage = DEFAULT_EXECUTE_MESSAGE, emitM
     });
 };
 
-const METHOD_NAME$Z = "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.
  *
@@ -17827,7 +18216,7 @@ const METHOD_NAME$Z = "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$Z, {
+        swarm$1.loggerService.log(METHOD_NAME$_, {
             toolSchema,
         });
     // Register the tool in the validation and schema services
@@ -17841,7 +18230,7 @@ const addTool = beginContext((toolSchema) => {
  * Adds navigation functionality to an agent by creating a tool that allows navigation to a specified agent.
  * @module addAgentNavigation
  */
-const METHOD_NAME$Y = "function.alias.addAgentNavigation";
+const METHOD_NAME$Z = "function.alias.addAgentNavigation";
 const DEFAULT_SKIP_PLACEHOLDER$1 = "Navigation canceled";
 /**
  * Creates and registers a navigation tool for an agent to navigate to another specified agent.
@@ -17855,7 +18244,7 @@ const DEFAULT_SKIP_PLACEHOLDER$1 = "Navigation canceled";
  * @returns {ReturnType<typeof addTool>} The result of adding the navigation tool.
  */
 const addAgentNavigation = beginContext(({ toolName, docNote, description, navigateTo, skipPlaceholder = DEFAULT_SKIP_PLACEHOLDER$1, ...navigateProps }) => {
-    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$Z);
     const navigate = createNavigateToAgent(navigateProps);
     return addTool({
         toolName,
@@ -17884,7 +18273,7 @@ const addAgentNavigation = beginContext(({ toolName, docNote, description, navig
  * Adds triage navigation functionality to an agent by creating a tool that facilitates navigation to a triage agent.
  * @module addTriageNavigation
  */
-const METHOD_NAME$X = "function.alias.addTriageNavigation";
+const METHOD_NAME$Y = "function.alias.addTriageNavigation";
 const DEFAULT_SKIP_PLACEHOLDER = "Navigation canceled";
 /**
  * Creates and registers a triage navigation tool for an agent to navigate to a triage agent.
@@ -17897,7 +18286,7 @@ const DEFAULT_SKIP_PLACEHOLDER = "Navigation canceled";
  * @returns {ReturnType<typeof addTool>} The result of adding the triage navigation tool.
  */
 const addTriageNavigation = beginContext(({ toolName, docNote, description, skipPlaceholder = DEFAULT_SKIP_PLACEHOLDER, ...navigateProps }) => {
-    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$Y);
     const navigate = createNavigateToTriageAgent(navigateProps);
     return addTool({
         toolName,
@@ -17923,7 +18312,7 @@ const addTriageNavigation = beginContext(({ toolName, docNote, description, skip
 });
 
 /** @constant {string} METHOD_NAME - The name of the method used for logging */
-const METHOD_NAME$W = "function.setup.addWiki";
+const METHOD_NAME$X = "function.setup.addWiki";
 /**
  * Adds a wiki schema to the system
  * @function addWiki
@@ -17932,7 +18321,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$X, {
             wikiSchema,
         });
     swarm$1.wikiValidationService.addWiki(wikiSchema.wikiName, wikiSchema);
@@ -17940,7 +18329,7 @@ const addWiki = beginContext((wikiSchema) => {
     return wikiSchema.wikiName;
 });
 
-const METHOD_NAME$V = "function.setup.addAgent";
+const METHOD_NAME$W = "function.setup.addAgent";
 /**
  * Adds a new agent to the agent registry for use within the swarm system.
  *
@@ -17960,7 +18349,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$W, {
             agentSchema,
         });
     // Register the agent in the validation and schema services
@@ -17970,7 +18359,7 @@ const addAgent = beginContext((agentSchema) => {
     return agentSchema.agentName;
 });
 
-const METHOD_NAME$U = "function.setup.addCompletion";
+const METHOD_NAME$V = "function.setup.addCompletion";
 /**
  * Adds a completion engine to the registry for use by agents in the swarm system.
  *
@@ -17990,7 +18379,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$V, {
             completionSchema,
         });
     // Register the completion in the validation and schema services
@@ -18000,7 +18389,7 @@ const addCompletion = beginContext((completionSchema) => {
     return completionSchema.completionName;
 });
 
-const METHOD_NAME$T = "function.setup.addSwarm";
+const METHOD_NAME$U = "function.setup.addSwarm";
 /**
  * Adds a new swarm to the system for managing client sessions.
  *
@@ -18020,7 +18409,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$U, {
             swarmSchema,
         });
     // Register the swarm in the validation and schema services
@@ -18030,7 +18419,7 @@ const addSwarm = beginContext((swarmSchema) => {
     return swarmSchema.swarmName;
 });
 
-const METHOD_NAME$S = "function.setup.addMCP";
+const METHOD_NAME$T = "function.setup.addMCP";
 /**
  * Registers a new MCP (Model Context Protocol) schema in the system.
  * @param mcpSchema - The MCP schema to register.
@@ -18038,7 +18427,7 @@ const METHOD_NAME$S = "function.setup.addMCP";
  */
 const addMCP = beginContext((mcpSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$S, {
+        swarm$1.loggerService.log(METHOD_NAME$T, {
             mcpSchema,
         });
     swarm$1.mcpValidationService.addMCP(mcpSchema.mcpName, mcpSchema);
@@ -18046,7 +18435,7 @@ const addMCP = beginContext((mcpSchema) => {
     return mcpSchema.mcpName;
 });
 
-const METHOD_NAME$R = "function.setup.addState";
+const METHOD_NAME$S = "function.setup.addState";
 /**
  * Adds a new state to the state registry for use within the swarm system.
  *
@@ -18068,7 +18457,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$S, {
             stateSchema,
         });
     // Register the policy with StateValidationService for runtime validation
@@ -18085,7 +18474,7 @@ const addState = beginContext((stateSchema) => {
     return stateSchema.stateName;
 });
 
-const METHOD_NAME$Q = "function.setup.addEmbedding";
+const METHOD_NAME$R = "function.setup.addEmbedding";
 /**
  * Adds a new embedding engine to the embedding registry for use within the swarm system.
  *
@@ -18105,7 +18494,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$R, {
             embeddingSchema,
         });
     // Register the embedding in the validation and schema services
@@ -18115,7 +18504,7 @@ const addEmbedding = beginContext((embeddingSchema) => {
     return embeddingSchema.embeddingName;
 });
 
-const METHOD_NAME$P = "function.setup.addStorage";
+const METHOD_NAME$Q = "function.setup.addStorage";
 /**
  * Adds a new storage engine to the storage registry for use within the swarm system.
  *
@@ -18137,7 +18526,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$Q, {
             storageSchema,
         });
     // Register the storage in the validation and schema services
@@ -18154,7 +18543,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$P = "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.
@@ -18170,7 +18559,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$P, {
             policySchema,
         });
     // Register the policy with PolicyValidationService for runtime validation
@@ -18211,7 +18600,7 @@ const addCompute = beginContext((computeSchema) => {
  * @description Method name for the addPipeline operation.
  * @private
  */
-const METHOD_NAME$N = "function.setup.addPipeline";
+const METHOD_NAME$O = "function.setup.addPipeline";
 /**
  * @function addPipeline
  * @description Registers a pipeline schema, validates it, and adds it to the pipeline schema service.
@@ -18221,7 +18610,7 @@ const METHOD_NAME$N = "function.setup.addPipeline";
  */
 const addPipeline = beginContext((pipelineSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$N, {
+        swarm$1.loggerService.log(METHOD_NAME$O, {
             pipelineSchema,
         });
     swarm$1.pipelineValidationService.addPipeline(pipelineSchema.pipelineName, pipelineSchema);
@@ -18229,7 +18618,7 @@ const addPipeline = beginContext((pipelineSchema) => {
     return pipelineSchema.pipelineName;
 });
 
-const METHOD_NAME$M = "function.test.overrideAgent";
+const METHOD_NAME$N = "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.
@@ -18253,13 +18642,14 @@ const METHOD_NAME$M = "function.test.overrideAgent";
  */
 const overrideAgent = beginContext((agentSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$M, {
+        swarm$1.loggerService.log(METHOD_NAME$N, {
             agentSchema,
         });
+    swarm$1.agentSchemaService.get(agentSchema.agentName);
     return swarm$1.agentSchemaService.override(agentSchema.agentName, agentSchema);
 });
 
-const METHOD_NAME$L = "function.test.overrideCompletion";
+const METHOD_NAME$M = "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.
@@ -18283,13 +18673,13 @@ const METHOD_NAME$L = "function.test.overrideCompletion";
  */
 const overrideCompletion = beginContext((completionSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$L, {
+        swarm$1.loggerService.log(METHOD_NAME$M, {
             completionSchema,
         });
     return swarm$1.completionSchemaService.override(completionSchema.completionName, completionSchema);
 });
 
-const METHOD_NAME$K = "function.test.overrideEmbeding";
+const METHOD_NAME$L = "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.
@@ -18315,13 +18705,13 @@ const METHOD_NAME$K = "function.test.overrideEmbeding";
  */
 const overrideEmbeding = beginContext((embeddingSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$K, {
+        swarm$1.loggerService.log(METHOD_NAME$L, {
             embeddingSchema,
         });
     return swarm$1.embeddingSchemaService.override(embeddingSchema.embeddingName, embeddingSchema);
 });
 
-const METHOD_NAME$J = "function.test.overridePolicy";
+const METHOD_NAME$K = "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.
@@ -18345,13 +18735,13 @@ const METHOD_NAME$J = "function.test.overridePolicy";
  */
 const overridePolicy = beginContext((policySchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$J, {
+        swarm$1.loggerService.log(METHOD_NAME$K, {
             policySchema,
         });
     return swarm$1.policySchemaService.override(policySchema.policyName, policySchema);
 });
 
-const METHOD_NAME$I = "function.test.overrideState";
+const METHOD_NAME$J = "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.
@@ -18376,13 +18766,13 @@ const METHOD_NAME$I = "function.test.overrideState";
  */
 const overrideState = beginContext((stateSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$I, {
+        swarm$1.loggerService.log(METHOD_NAME$J, {
             stateSchema,
         });
     return swarm$1.stateSchemaService.override(stateSchema.stateName, stateSchema);
 });
 
-const METHOD_NAME$H = "function.test.overrideStorage";
+const METHOD_NAME$I = "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.
@@ -18408,13 +18798,13 @@ const METHOD_NAME$H = "function.test.overrideStorage";
  */
 const overrideStorage = beginContext((storageSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$H, {
+        swarm$1.loggerService.log(METHOD_NAME$I, {
             storageSchema,
         });
     return swarm$1.storageSchemaService.override(storageSchema.storageName, storageSchema);
 });
 
-const METHOD_NAME$G = "function.test.overrideSwarm";
+const METHOD_NAME$H = "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.
@@ -18438,13 +18828,13 @@ const METHOD_NAME$G = "function.test.overrideSwarm";
  */
 const overrideSwarm = beginContext((swarmSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$G, {
+        swarm$1.loggerService.log(METHOD_NAME$H, {
             swarmSchema,
         });
     return swarm$1.swarmSchemaService.override(swarmSchema.swarmName, swarmSchema);
 });
 
-const METHOD_NAME$F = "function.test.overrideTool";
+const METHOD_NAME$G = "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.
@@ -18468,13 +18858,13 @@ const METHOD_NAME$F = "function.test.overrideTool";
  */
 const overrideTool = beginContext((toolSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$F, {
+        swarm$1.loggerService.log(METHOD_NAME$G, {
             toolSchema,
         });
     return swarm$1.toolSchemaService.override(toolSchema.toolName, toolSchema);
 });
 
-const METHOD_NAME$E = "function.test.overrideMCP";
+const METHOD_NAME$F = "function.test.overrideMCP";
 /**
  * Overrides an existing MCP (Model Context Protocol) schema with a new or partial schema.
  * @param mcpSchema - The MCP schema containing the name and optional properties to override.
@@ -18482,13 +18872,13 @@ const METHOD_NAME$E = "function.test.overrideMCP";
  */
 const overrideMCP = beginContext((mcpSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$E, {
+        swarm$1.loggerService.log(METHOD_NAME$F, {
             mcpSchema,
         });
     return swarm$1.mcpSchemaService.override(mcpSchema.mcpName, mcpSchema);
 });
 
-const METHOD_NAME$D = "function.test.overrideWiki";
+const METHOD_NAME$E = "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.
@@ -18512,7 +18902,7 @@ const METHOD_NAME$D = "function.test.overrideWiki";
  */
 const overrideWiki = beginContext((wikiSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$D, {
+        swarm$1.loggerService.log(METHOD_NAME$E, {
             wikiSchema,
         });
     return swarm$1.wikiSchemaService.override(wikiSchema.wikiName, wikiSchema);
@@ -18527,7 +18917,7 @@ const overrideWiki = beginContext((wikiSchema) => {
  * @description Method name for the overrideCompute operation.
  * @private
  */
-const METHOD_NAME$C = "function.test.overrideCompute";
+const METHOD_NAME$D = "function.test.overrideCompute";
 /**
  * @function overrideCompute
  * @description Overrides an existing compute schema with provided partial updates.
@@ -18536,7 +18926,7 @@ const METHOD_NAME$C = "function.test.overrideCompute";
  */
 const overrideCompute = beginContext((computeSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$C, {
+        swarm$1.loggerService.log(METHOD_NAME$D, {
             computeSchema,
         });
     return swarm$1.computeSchemaService.override(computeSchema.computeName, computeSchema);
@@ -18551,7 +18941,7 @@ const overrideCompute = beginContext((computeSchema) => {
  * @description Method name for the overridePipeline operation.
  * @private
  */
-const METHOD_NAME$B = "function.test.overridePipeline";
+const METHOD_NAME$C = "function.test.overridePipeline";
 /**
  * @function overridePipeline
  * @description Overrides an existing pipeline schema with provided partial updates.
@@ -18561,13 +18951,13 @@ const METHOD_NAME$B = "function.test.overridePipeline";
  */
 const overridePipeline = beginContext((pipelineSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$B, {
+        swarm$1.loggerService.log(METHOD_NAME$C, {
             pipelineSchema,
         });
     return swarm$1.pipelineSchemaService.override(pipelineSchema.pipelineName, pipelineSchema);
 });
 
-const METHOD_NAME$A = "function.other.markOnline";
+const METHOD_NAME$B = "function.other.markOnline";
 /**
  * Marks a client as online in the specified swarm.
  *
@@ -18579,16 +18969,16 @@ const METHOD_NAME$A = "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$A, {
+        swarm.loggerService.log(METHOD_NAME$B, {
             clientId,
         });
     // Validate the swarm name
-    swarm.swarmValidationService.validate(swarmName, METHOD_NAME$A);
+    swarm.swarmValidationService.validate(swarmName, METHOD_NAME$B);
     // Run the operation in the method context
     return await MethodContextService.runInContext(async () => {
-        await swarm.aliveService.markOnline(clientId, swarmName, METHOD_NAME$A);
+        await swarm.aliveService.markOnline(clientId, swarmName, METHOD_NAME$B);
     }, {
-        methodName: METHOD_NAME$A,
+        methodName: METHOD_NAME$B,
         agentName: "",
         policyName: "",
         stateName: "",
@@ -18600,7 +18990,7 @@ const markOnline = async (clientId, swarmName) => {
     });
 };
 
-const METHOD_NAME$z = "function.other.markOffline";
+const METHOD_NAME$A = "function.other.markOffline";
 /**
  * Marks a client as offline in the specified swarm.
  *
@@ -18615,14 +19005,14 @@ const METHOD_NAME$z = "function.other.markOffline";
  */
 const markOffline = async (clientId, swarmName) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm.loggerService.log(METHOD_NAME$z, {
+        swarm.loggerService.log(METHOD_NAME$A, {
             clientId,
         });
-    swarm.swarmValidationService.validate(swarmName, METHOD_NAME$z);
+    swarm.swarmValidationService.validate(swarmName, METHOD_NAME$A);
     return await MethodContextService.runInContext(async () => {
-        await swarm.aliveService.markOffline(clientId, swarmName, METHOD_NAME$z);
+        await swarm.aliveService.markOffline(clientId, swarmName, METHOD_NAME$A);
     }, {
-        methodName: METHOD_NAME$z,
+        methodName: METHOD_NAME$A,
         agentName: "",
         policyName: "",
         stateName: "",
@@ -18635,7 +19025,7 @@ const markOffline = async (clientId, swarmName) => {
 };
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$y = "function.commit.commitSystemMessage";
+const METHOD_NAME$z = "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.
@@ -18654,20 +19044,20 @@ const METHOD_NAME$y = "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$y, {
+        swarm$1.loggerService.log(METHOD_NAME$z, {
             content,
             clientId,
             agentName,
         });
     // Validate the agent exists
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$y);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$z);
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$y);
+    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$y);
+    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$y, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$z, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "commitSystemMessage" skipped due to the agent change', {
@@ -18678,10 +19068,10 @@ const commitSystemMessage = beginContext(async (content, clientId, agentName) =>
         return;
     }
     // Commit the system message via SessionPublicService
-    await swarm$1.sessionPublicService.commitSystemMessage(content, METHOD_NAME$y, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitSystemMessage(content, METHOD_NAME$z, clientId, swarmName);
 });
 
-const METHOD_NAME$x = "function.commit.commitSystemMessage";
+const METHOD_NAME$y = "function.commit.commitSystemMessage";
 /**
  * Commits a user message to the active agent's history in a swarm session without triggering a response.
  *
@@ -18700,19 +19090,19 @@ const METHOD_NAME$x = "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$x, {
+        swarm$1.loggerService.log(METHOD_NAME$y, {
             content,
             clientId,
             agentName,
             mode,
         });
     // Validate the agent, session, and swarm to ensure they exist and are accessible
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$x);
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$x);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$y);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$y);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$x);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$y);
     // Check if the specified agent is still the active agent in the swarm session
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$x, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$y, clientId, swarmName);
     if (currentAgentName !== agentName) {
         // Log a skip message if the agent has changed during the operation
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
@@ -18725,18 +19115,18 @@ const commitUserMessage = beginContext(async (content, mode, clientId, agentName
     }
     if (payload) {
         return await PayloadContextService.runInContext(async () => {
-            await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$x, clientId, swarmName);
+            await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$y, 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$x, clientId, swarmName);
+    return await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$y, clientId, swarmName);
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$w = "function.commit.commitSystemMessageForce";
+const METHOD_NAME$x = "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.
@@ -18755,20 +19145,20 @@ const METHOD_NAME$w = "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$w, {
+        swarm$1.loggerService.log(METHOD_NAME$x, {
             content,
             clientId,
         });
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$w);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$x);
     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$x);
     // Commit the system message via SessionPublicService without agent checks
-    await swarm$1.sessionPublicService.commitSystemMessage(content, METHOD_NAME$w, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitSystemMessage(content, METHOD_NAME$x, clientId, swarmName);
 });
 
-const METHOD_NAME$v = "function.commit.commitSystemMessage";
+const METHOD_NAME$w = "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.
  *
@@ -18786,29 +19176,29 @@ const METHOD_NAME$v = "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$v, {
+        swarm$1.loggerService.log(METHOD_NAME$w, {
             content,
             clientId,
             mode,
         });
     // Validate the session and swarm to ensure they exist and are accessible
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$v);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$w);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$v);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$w);
     if (payload) {
         return await PayloadContextService.runInContext(async () => {
-            await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$v, clientId, swarmName);
+            await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$w, 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$v, clientId, swarmName);
+    return await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$w, clientId, swarmName);
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$u = "function.commit.commitAssistantMessage";
+const METHOD_NAME$v = "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.
@@ -18826,20 +19216,20 @@ const METHOD_NAME$u = "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$u, {
+        swarm$1.loggerService.log(METHOD_NAME$v, {
             content,
             clientId,
             agentName,
         });
     // Validate the agent exists
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$u);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$v);
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$u);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$v);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$u);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$v);
     // Check if the current agent matches the provided agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$u, clientId, swarmName);
+    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 "commitAssistantMessage" skipped due to the agent change', {
@@ -18850,11 +19240,11 @@ const commitAssistantMessage = beginContext(async (content, clientId, agentName)
         return;
     }
     // Commit the assistant message via SessionPublicService
-    await swarm$1.sessionPublicService.commitAssistantMessage(content, METHOD_NAME$u, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitAssistantMessage(content, METHOD_NAME$v, clientId, swarmName);
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$t = "function.commit.commitAssistantMessageForce";
+const METHOD_NAME$u = "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.
@@ -18873,21 +19263,21 @@ const METHOD_NAME$t = "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$t, {
+        swarm$1.loggerService.log(METHOD_NAME$u, {
             content,
             clientId,
         });
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$t);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$u);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$t);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$u);
     // Commit the assistant message via SessionPublicService without agent checks
-    await swarm$1.sessionPublicService.commitAssistantMessage(content, METHOD_NAME$t, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitAssistantMessage(content, METHOD_NAME$u, clientId, swarmName);
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$s = "function.commit.cancelOutput";
+const METHOD_NAME$t = "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.
@@ -18903,19 +19293,19 @@ const METHOD_NAME$s = "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$s, {
+        swarm$1.loggerService.log(METHOD_NAME$t, {
             clientId,
             agentName,
         });
     // Validate the agent exists
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$s);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$t);
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$s);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$t);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$s);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$t);
     // Check if the current agent matches the provided agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$s, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$t, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "cancelOutput" skipped due to the agent change', {
@@ -18926,11 +19316,11 @@ const cancelOutput = beginContext(async (clientId, agentName) => {
         return;
     }
     // Perform the output cancellation via SwarmPublicService
-    await swarm$1.swarmPublicService.cancelOutput(METHOD_NAME$s, clientId, swarmName);
+    await swarm$1.swarmPublicService.cancelOutput(METHOD_NAME$t, clientId, swarmName);
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$r = "function.commit.cancelOutputForce";
+const METHOD_NAME$s = "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.
@@ -18947,20 +19337,20 @@ const METHOD_NAME$r = "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$r, {
+        swarm$1.loggerService.log(METHOD_NAME$s, {
             clientId,
         });
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$r);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$s);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$r);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$s);
     // Perform the output cancellation via SwarmPublicService without agent checks
-    await swarm$1.swarmPublicService.cancelOutput(METHOD_NAME$r, clientId, swarmName);
+    await swarm$1.swarmPublicService.cancelOutput(METHOD_NAME$s, clientId, swarmName);
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$q = "function.commit.commitStopToolsForce";
+const METHOD_NAME$r = "function.commit.commitStopToolsForce";
 /**
  * Forcefully prevents the next tool from being executed for a specific client in the swarm system, without checking the active agent.
  * Validates the session and swarm, then proceeds with stopping tool execution regardless of the current agent state.
@@ -18978,21 +19368,21 @@ const METHOD_NAME$q = "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$q, {
+        swarm$1.loggerService.log(METHOD_NAME$r, {
             clientId,
-            METHOD_NAME: METHOD_NAME$q,
+            METHOD_NAME: METHOD_NAME$r,
         });
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$q);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$r);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$q);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$r);
     // Commit the stop of the next tool execution via SessionPublicService without agent checks
-    await swarm$1.sessionPublicService.commitStopTools(METHOD_NAME$q, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitStopTools(METHOD_NAME$r, clientId, swarmName);
 });
 
 /** @constant {string} METHOD_NAME - The name of the method used for logging and validation */
-const METHOD_NAME$p = "function.target.question";
+const METHOD_NAME$q = "function.target.question";
 /**
  * Initiates a question process within a chat context
  * @function question
@@ -19004,21 +19394,21 @@ const METHOD_NAME$p = "function.target.question";
  */
 const question = beginContext(async (message, clientId, agentName, wikiName) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$p, {
+        swarm$1.loggerService.log(METHOD_NAME$q, {
             message,
             clientId,
             agentName,
             wikiName,
         });
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$p);
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$p);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$q);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$q);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$p);
-    swarm$1.wikiValidationService.validate(wikiName, METHOD_NAME$p);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$q);
+    swarm$1.wikiValidationService.validate(wikiName, METHOD_NAME$q);
     if (!swarm$1.agentValidationService.hasWiki(agentName, wikiName)) {
-        throw new Error(`agent-swarm ${METHOD_NAME$p} ${wikiName} not registered in ${agentName}`);
+        throw new Error(`agent-swarm ${METHOD_NAME$q} ${wikiName} not registered in ${agentName}`);
     }
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$p, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$q, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "question" skipped due to the agent change', {
@@ -19041,7 +19431,7 @@ const question = beginContext(async (message, clientId, agentName, wikiName) =>
 });
 
 /** @constant {string} METHOD_NAME - The name of the method used for logging and validation */
-const METHOD_NAME$o = "function.target.questionForce";
+const METHOD_NAME$p = "function.target.questionForce";
 /**
  * Initiates a forced question process within a chat context
  * @function questionForce
@@ -19052,17 +19442,17 @@ const METHOD_NAME$o = "function.target.questionForce";
  */
 const questionForce = beginContext(async (message, clientId, wikiName) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$o, {
+        swarm$1.loggerService.log(METHOD_NAME$p, {
             message,
             clientId,
             wikiName,
         });
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$o);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$p);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$o);
-    swarm$1.wikiValidationService.validate(wikiName, METHOD_NAME$o);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$p);
+    swarm$1.wikiValidationService.validate(wikiName, METHOD_NAME$p);
     const { getChat, callbacks } = swarm$1.wikiSchemaService.get(wikiName);
-    const agentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$o, clientId, swarmName);
+    const agentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$p, clientId, swarmName);
     const args = {
         clientId,
         message,
@@ -19074,7 +19464,7 @@ const questionForce = beginContext(async (message, clientId, wikiName) => {
     return await getChat(args);
 });
 
-const METHOD_NAME$n = "function.target.disposeConnection";
+const METHOD_NAME$o = "function.target.disposeConnection";
 /**
  * Disposes of a client session and all related resources within a swarm.
  *
@@ -19091,10 +19481,10 @@ const METHOD_NAME$n = "function.target.disposeConnection";
  * @example
  * await disposeConnection("client-123", "TaskSwarm");
  */
-const disposeConnection = beginContext(async (clientId, swarmName, methodName = METHOD_NAME$n) => {
+const disposeConnection = beginContext(async (clientId, swarmName, methodName = METHOD_NAME$o) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$n, {
+        swarm$1.loggerService.log(METHOD_NAME$o, {
             clientId,
             swarmName,
         });
@@ -19199,7 +19589,7 @@ const disposeConnection = beginContext(async (clientId, swarmName, methodName =
     PersistMemoryAdapter.dispose(clientId);
 });
 
-const METHOD_NAME$m = "function.target.makeAutoDispose";
+const METHOD_NAME$n = "function.target.makeAutoDispose";
 /**
  * Default timeout in seconds before auto-dispose is triggered.
  * @constant {number}
@@ -19230,7 +19620,7 @@ const DEFAULT_TIMEOUT = 15 * 60;
 const makeAutoDispose = beginContext((clientId, swarmName, { timeoutSeconds = DEFAULT_TIMEOUT, onDestroy, } = {}) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$m, {
+        swarm$1.loggerService.log(METHOD_NAME$n, {
             clientId,
             swarmName,
         });
@@ -19263,7 +19653,7 @@ const makeAutoDispose = beginContext((clientId, swarmName, { timeoutSeconds = DE
     };
 });
 
-const METHOD_NAME$l = "function.target.notify";
+const METHOD_NAME$m = "function.target.notify";
 /**
  * Sends a notification message as output from the swarm session without executing an incoming message.
  *
@@ -19283,23 +19673,23 @@ const METHOD_NAME$l = "function.target.notify";
 const notify = beginContext(async (content, clientId, agentName) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$l, {
+        swarm$1.loggerService.log(METHOD_NAME$m, {
             content,
             clientId,
             agentName,
         });
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$l);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$m);
     // Check if the session mode is "makeConnection"
     if (swarm$1.sessionValidationService.getSessionMode(clientId) !==
         "makeConnection") {
         throw new Error(`agent-swarm-kit notify session is not makeConnection clientId=${clientId}`);
     }
     // Validate the agent, session, and swarm
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$l);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$m);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$l);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$m);
     // Check if the specified agent is still the active agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$l, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$m, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "notify" skipped due to the agent change', {
@@ -19310,10 +19700,10 @@ const notify = beginContext(async (content, clientId, agentName) => {
         return;
     }
     // Notify the content directly via the session public service
-    return await swarm$1.sessionPublicService.notify(content, METHOD_NAME$l, clientId, swarmName);
+    return await swarm$1.sessionPublicService.notify(content, METHOD_NAME$m, clientId, swarmName);
 });
 
-const METHOD_NAME$k = "function.target.notifyForce";
+const METHOD_NAME$l = "function.target.notifyForce";
 /**
  * Sends a notification message as output from the swarm session without executing an incoming message.
  *
@@ -19332,11 +19722,11 @@ const METHOD_NAME$k = "function.target.notifyForce";
 const notifyForce = beginContext(async (content, clientId) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$k, {
+        swarm$1.loggerService.log(METHOD_NAME$l, {
             content,
             clientId,
         });
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$k);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$l);
     // Check if the session mode is "makeConnection"
     if (swarm$1.sessionValidationService.getSessionMode(clientId) !==
         "makeConnection") {
@@ -19344,12 +19734,12 @@ const notifyForce = beginContext(async (content, clientId) => {
     }
     // Validate the agent, session, and swarm
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$k);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$l);
     // Notify the content directly via the session public service
-    return await swarm$1.sessionPublicService.notify(content, METHOD_NAME$k, clientId, swarmName);
+    return await swarm$1.sessionPublicService.notify(content, METHOD_NAME$l, clientId, swarmName);
 });
 
-const METHOD_NAME$j = "function.target.runStateless";
+const METHOD_NAME$k = "function.target.runStateless";
 /**
  * Executes a message statelessly with an agent in a swarm session, bypassing chat history.
  *
@@ -19372,19 +19762,19 @@ const runStateless = beginContext(async (content, clientId, agentName) => {
     const executionId = functoolsKit.randomString();
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$j, {
+        swarm$1.loggerService.log(METHOD_NAME$k, {
             content,
             clientId,
             agentName,
             executionId,
         });
     // Validate the agent, session, and swarm
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$j);
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$j);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$k);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$k);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$j);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$k);
     // Check if the specified agent is still the active agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$j, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$k, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "runStateless" skipped due to the agent change', {
@@ -19403,7 +19793,7 @@ const runStateless = beginContext(async (content, clientId, agentName) => {
                 agentName,
                 swarmName,
             });
-            const result = await swarm$1.sessionPublicService.run(content, METHOD_NAME$j, clientId, swarmName);
+            const result = await swarm$1.sessionPublicService.run(content, METHOD_NAME$k, clientId, swarmName);
             isFinished = swarm$1.perfService.endExecution(executionId, clientId, result.length);
             swarm$1.busService.commitExecutionEnd(clientId, {
                 agentName,
@@ -19423,7 +19813,7 @@ const runStateless = beginContext(async (content, clientId, agentName) => {
     });
 });
 
-const METHOD_NAME$i = "function.target.runStatelessForce";
+const METHOD_NAME$j = "function.target.runStatelessForce";
 /**
  * Executes a message statelessly with the active agent in a swarm session, bypassing chat history and forcing execution regardless of agent activity.
  *
@@ -19444,22 +19834,22 @@ const runStatelessForce = beginContext(async (content, clientId) => {
     const executionId = functoolsKit.randomString();
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$i, {
+        swarm$1.loggerService.log(METHOD_NAME$j, {
             content,
             clientId,
             executionId,
         });
     // Validate the session and swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$i);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$j);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$i);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$j);
     // Execute the command statelessly within an execution context with performance tracking
     return ExecutionContextService.runInContext(async () => {
         let isFinished = false;
         swarm$1.perfService.startExecution(executionId, clientId, content.length);
         try {
             swarm$1.busService.commitExecutionBegin(clientId, { swarmName });
-            const result = await swarm$1.sessionPublicService.run(content, METHOD_NAME$i, clientId, swarmName);
+            const result = await swarm$1.sessionPublicService.run(content, METHOD_NAME$j, clientId, swarmName);
             isFinished = swarm$1.perfService.endExecution(executionId, clientId, result.length);
             swarm$1.busService.commitExecutionEnd(clientId, { swarmName });
             return result;
@@ -19486,7 +19876,7 @@ const SCHEDULED_DELAY$1 = 1000;
  * @constant {number}
  */
 const RATE_DELAY = 10000;
-const METHOD_NAME$h = "function.target.makeConnection";
+const METHOD_NAME$i = "function.target.makeConnection";
 /**
  * Internal implementation of the connection factory for a client to a swarm.
  *
@@ -19501,21 +19891,21 @@ const METHOD_NAME$h = "function.target.makeConnection";
 const makeConnectionInternal = (connector, clientId, swarmName) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$h, {
+        swarm$1.loggerService.log(METHOD_NAME$i, {
             clientId,
             swarmName,
         });
     // Validate the swarm and initialize the session
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$h);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$i);
     swarm$1.sessionValidationService.addSession(clientId, swarmName, "makeConnection");
     // Create a queued send function using the session public service
-    const send = functoolsKit.queued(swarm$1.sessionPublicService.connect(connector, METHOD_NAME$h, clientId, swarmName));
+    const send = functoolsKit.queued(swarm$1.sessionPublicService.connect(connector, METHOD_NAME$i, clientId, swarmName));
     // Return a wrapped send function with validation and agent context
     return (async (outgoing) => {
-        swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$h);
+        swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$i);
         return await send({
             data: outgoing,
-            agentName: await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$h, clientId, swarmName),
+            agentName: await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$i, clientId, swarmName),
             clientId,
         });
     });
@@ -19598,13 +19988,13 @@ makeConnection.scheduled = (connector, clientId, swarmName, { delay = SCHEDULED_
             await online();
             if (payload) {
                 return await PayloadContextService.runInContext(async () => {
-                    await swarm$1.sessionPublicService.commitUserMessage(content, "user", METHOD_NAME$h, clientId, swarmName);
+                    await swarm$1.sessionPublicService.commitUserMessage(content, "user", METHOD_NAME$i, clientId, swarmName);
                 }, {
                     clientId,
                     payload,
                 });
             }
-            await swarm$1.sessionPublicService.commitUserMessage(content, "user", METHOD_NAME$h, clientId, swarmName);
+            await swarm$1.sessionPublicService.commitUserMessage(content, "user", METHOD_NAME$i, clientId, swarmName);
         }),
         delay,
     });
@@ -19667,7 +20057,7 @@ makeConnection.rate = (connector, clientId, swarmName, { delay = RATE_DELAY } =
     };
 };
 
-const METHOD_NAME$g = "function.target.complete";
+const METHOD_NAME$h = "function.target.complete";
 /**
  * Creates a complete function with time-to-live (TTL) and queuing capabilities.
  *
@@ -19720,7 +20110,7 @@ const complete = beginContext(async (content, clientId, swarmName, payload = nul
     const executionId = functoolsKit.randomString();
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$g, {
+        swarm$1.loggerService.log(METHOD_NAME$h, {
             content,
             clientId,
             executionId,
@@ -19738,7 +20128,7 @@ const complete = beginContext(async (content, clientId, swarmName, payload = nul
             swarm$1.navigationValidationService.beginMonit(clientId, swarmName);
             try {
                 swarm$1.busService.commitExecutionBegin(clientId, { swarmName });
-                const result = await run(METHOD_NAME$g, content);
+                const result = await run(METHOD_NAME$h, content);
                 isFinished = swarm$1.perfService.endExecution(executionId, clientId, result.length);
                 swarm$1.busService.commitExecutionEnd(clientId, { swarmName });
                 return result;
@@ -19768,7 +20158,7 @@ const complete = beginContext(async (content, clientId, swarmName, payload = nul
  * @constant {number}
  */
 const SCHEDULED_DELAY = 1000;
-const METHOD_NAME$f = "function.target.session";
+const METHOD_NAME$g = "function.target.session";
 /**
  * Internal implementation of the session factory for a client and swarm.
  *
@@ -19783,23 +20173,23 @@ const sessionInternal = (clientId, swarmName, { onDispose = () => { } } = {}) =>
     const executionId = functoolsKit.randomString();
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$f, {
+        swarm$1.loggerService.log(METHOD_NAME$g, {
             clientId,
             swarmName,
             executionId,
         });
     // Validate the swarm and initialize the session
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$f);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$g);
     swarm$1.sessionValidationService.addSession(clientId, swarmName, "session");
     const complete = functoolsKit.queued(async (content) => {
-        swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$f);
+        swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$g);
         return ExecutionContextService.runInContext(async () => {
             let isFinished = false;
             swarm$1.perfService.startExecution(executionId, clientId, content.length);
             swarm$1.navigationValidationService.beginMonit(clientId, swarmName);
             try {
                 swarm$1.busService.commitExecutionBegin(clientId, { swarmName });
-                const result = await swarm$1.sessionPublicService.execute(content, "user", METHOD_NAME$f, clientId, swarmName);
+                const result = await swarm$1.sessionPublicService.execute(content, "user", METHOD_NAME$g, clientId, swarmName);
                 isFinished = swarm$1.perfService.endExecution(executionId, clientId, result.length);
                 swarm$1.busService.commitExecutionEnd(clientId, { swarmName });
                 return result;
@@ -19820,7 +20210,7 @@ const sessionInternal = (clientId, swarmName, { onDispose = () => { } } = {}) =>
             return await complete(content);
         }),
         dispose: async () => {
-            await disposeConnection(clientId, swarmName, METHOD_NAME$f);
+            await disposeConnection(clientId, swarmName, METHOD_NAME$g);
             await onDispose();
         },
     };
@@ -19920,13 +20310,13 @@ session.scheduled = (clientId, swarmName, { delay = SCHEDULED_DELAY, onDispose }
             await online();
             if (payload) {
                 return await PayloadContextService.runInContext(async () => {
-                    return await swarm$1.sessionPublicService.commitUserMessage(content, "user", METHOD_NAME$f, clientId, swarmName);
+                    return await swarm$1.sessionPublicService.commitUserMessage(content, "user", METHOD_NAME$g, clientId, swarmName);
                 }, {
                     clientId,
                     payload,
                 });
             }
-            return await swarm$1.sessionPublicService.commitUserMessage(content, "user", METHOD_NAME$f, clientId, swarmName);
+            return await swarm$1.sessionPublicService.commitUserMessage(content, "user", METHOD_NAME$g, clientId, swarmName);
         }),
         delay,
     });
@@ -20014,7 +20404,7 @@ session.rate = (clientId, swarmName, { delay = SCHEDULED_DELAY, onDispose } = {}
  * @description Method name for the scope operation.
  * @private
  */
-const METHOD_NAME$e = "function.target.fork";
+const METHOD_NAME$f = "function.target.fork";
 /**
  * @function fork
  * @description Executes a provided function within a managed scope, handling session creation, validation, and cleanup.
@@ -20026,7 +20416,7 @@ const METHOD_NAME$e = "function.target.fork";
  */
 const fork = beginContext(async (runFn, { clientId, swarmName, onError }) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$e, {
+        swarm$1.loggerService.log(METHOD_NAME$f, {
             clientId,
             swarmName,
         });
@@ -20034,9 +20424,9 @@ const fork = beginContext(async (runFn, { clientId, swarmName, onError }) => {
         throw new Error(`agent-swarm scope Session already exists for clientId=${clientId}`);
     }
     swarm$1.sessionValidationService.addSession(clientId, swarmName, "scope");
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$e);
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$e);
-    const agentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$e, clientId, swarmName);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$f);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$f);
+    const agentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$f, clientId, swarmName);
     let result = null;
     try {
         result = (await runFn(clientId, agentName));
@@ -20046,11 +20436,61 @@ const fork = beginContext(async (runFn, { clientId, swarmName, onError }) => {
         onError && onError(error);
     }
     finally {
-        await disposeConnection(clientId, swarmName, METHOD_NAME$e);
+        await disposeConnection(clientId, swarmName, METHOD_NAME$f);
     }
     return result;
 });
 
+/**
+ * @module scope
+ * @description Provides a function to execute a specified function within a managed schema context, allowing overrides for schema services.
+ */
+/**
+ * @constant {string} METHOD_NAME
+ * @description Method name for the scope operation.
+ * @private
+ */
+const METHOD_NAME$e = "function.target.scope";
+/**
+ * @function scope
+ * @description Executes a provided function within a schema context, with optional overrides for schema services such as agents, completions, and pipelines.
+ * @template T - Type of the result returned by the run function.
+ * @param {Function} runFn - The function to execute within the schema context.
+ * @param {Partial<ISchemaContext["registry"]>} [options] - Optional overrides for schema services, with defaults from the swarm's schema services.
+ * @param {ToolRegistry} [options.agentSchemaService=swarm.agentSchemaService.registry] - Registry for agent schemas.
+ * @param {ToolRegistry} [options.completionSchemaService=swarm.completionSchemaService.registry] - Registry for completion schemas.
+ * @param {ToolRegistry} [options.computeSchemaService=swarm.computeSchemaService.registry] - Registry for compute schemas.
+ * @param {ToolRegistry} [options.embeddingSchemaService=swarm.embeddingSchemaService.registry] - Registry for embedding schemas.
+ * @param {ToolRegistry} [options.mcpSchemaService=swarm.mcpSchemaService.registry] - Registry for MCP schemas.
+ * @param {ToolRegistry} [options.pipelineSchemaService=swarm.pipelineSchemaService.registry] - Registry for pipeline schemas.
+ * @param {ToolRegistry} [options.policySchemaService=swarm.policySchemaService.registry] - Registry for policy schemas.
+ * @param {ToolRegistry} [options.stateSchemaService=swarm.stateSchemaService.registry] - Registry for state schemas.
+ * @param {ToolRegistry} [options.storageSchemaService=swarm.storageSchemaService.registry] - Registry for storage schemas.
+ * @param {ToolRegistry} [options.swarmSchemaService=swarm.swarmSchemaService.registry] - Registry for swarm schemas.
+ * @param {ToolRegistry} [options.toolSchemaService=swarm.toolSchemaService.registry] - Registry for tool schemas.
+ * @param {ToolRegistry} [options.wikiSchemaService=swarm.wikiSchemaService.registry] - Registry for wiki schemas.
+ * @returns {Promise<T>} The result of the executed function.
+ */
+const scope = async (runFn, { agentSchemaService = swarm$1.agentSchemaService.registry, completionSchemaService = swarm$1.completionSchemaService.registry, computeSchemaService = swarm$1.computeSchemaService.registry, embeddingSchemaService = swarm$1.embeddingSchemaService.registry, mcpSchemaService = swarm$1.mcpSchemaService.registry, pipelineSchemaService = swarm$1.pipelineSchemaService.registry, policySchemaService = swarm$1.policySchemaService.registry, stateSchemaService = swarm$1.stateSchemaService.registry, storageSchemaService = swarm$1.storageSchemaService.registry, swarmSchemaService = swarm$1.swarmSchemaService.registry, toolSchemaService = swarm$1.toolSchemaService.registry, wikiSchemaService = swarm$1.wikiSchemaService.registry, }) => {
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$e);
+    return await SchemaContextService.runInContext(runFn, {
+        registry: {
+            agentSchemaService,
+            completionSchemaService,
+            computeSchemaService,
+            embeddingSchemaService,
+            mcpSchemaService,
+            pipelineSchemaService,
+            policySchemaService,
+            stateSchemaService,
+            storageSchemaService,
+            swarmSchemaService,
+            toolSchemaService,
+            wikiSchemaService,
+        },
+    });
+};
+
 /**
  * @module startPipeline
  * @description Provides a function to initiate a pipeline execution with session validation, logging, and callback handling.
@@ -22781,6 +23221,7 @@ exports.PersistSwarm = PersistSwarm;
 exports.Policy = Policy;
 exports.RoundRobin = RoundRobin;
 exports.Schema = Schema;
+exports.SchemaContextService = SchemaContextService;
 exports.SharedCompute = SharedCompute;
 exports.SharedState = SharedState;
 exports.SharedStorage = SharedStorage;
@@ -22888,6 +23329,7 @@ exports.question = question;
 exports.questionForce = questionForce;
 exports.runStateless = runStateless;
 exports.runStatelessForce = runStatelessForce;
+exports.scope = scope;
 exports.session = session;
 exports.setConfig = setConfig;
 exports.startPipeline = startPipeline;