agent-swarm-kit 1.1.45 → 1.1.46

package/build/index.cjs

@@ -3565,6 +3565,64 @@ class AgentSchemaService {
     }
 }
 
+/**
+ * Checks if a given value is a plain JavaScript object.
+ * Returns `true` only for objects that inherit directly from `Object.prototype`, excluding arrays, null, and other non-object types.
+ *
+ * @param {any} obj - The value to check for being a plain object.
+ * @returns {boolean} Returns `true` if the value is a plain object (e.g., `{}` or `{ key: "value" }`), otherwise `false`.
+ *
+ * @example
+ * // Basic usage with various types
+ * console.log(isObject({}));              // true
+ * console.log(isObject({ key: "value" })); // true
+ * console.log(isObject([]));              // false (arrays are objects but not plain objects)
+ * console.log(isObject(null));            // false
+ * console.log(isObject("string"));        // false
+ * console.log(isObject(42));              // false
+ *
+ * @example
+ * // Testing with custom objects and prototypes
+ * const customObj = Object.create(null);
+ * console.log(isObject(customObj));       // false (does not inherit from Object.prototype)
+ * const plainObj = Object.create(Object.prototype);
+ * console.log(isObject(plainObj));        // true
+ *
+ * @remarks
+ * This function performs a strict check for plain objects by verifying:
+ * 1. The value’s type is `"object"` (via `typeof`), excluding primitives.
+ * 2. The value is not `null`.
+ * 3. The value’s prototype is exactly `Object.prototype`, distinguishing plain objects from arrays, functions,
+ *    or objects with custom prototypes (e.g., instances of classes or `Object.create(null)`).
+ * This is useful in scenarios requiring type safety, such as validating configuration objects or JSON-parsed data
+ * in the agent swarm system, where distinguishing between plain objects and other object-like types is critical.
+ *
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/getPrototypeOf|Object.getPrototypeOf}
+ * for details on prototype checking.
+ */
+const isObject = (obj) => {
+    if (typeof obj === "object" && obj !== null) {
+        return Object.getPrototypeOf(obj) === Object.prototype;
+    }
+    else {
+        return false;
+    }
+};
+
+const createToolRequest = ({ toolName, params, }) => {
+    if (!isObject(params)) {
+        throw new Error("agent-swarm createToolRequest params is not object");
+    }
+    return {
+        id: `call_${Math.random().toString(36).slice(2, 11)}`,
+        type: "function",
+        function: {
+            name: toolName,
+            arguments: params,
+        },
+    };
+};
+
 const AGENT_CHANGE_SYMBOL = Symbol("agent-change");
 const MODEL_RESQUE_SYMBOL = Symbol("model-resque");
 const TOOL_ERROR_SYMBOL = Symbol("tool-error");
@@ -4448,6 +4506,41 @@ class ClientAgent {
             clientId: this.params.clientId,
         });
     }
+    /**
+     * Commits a tool request to the agent's history and emits an event via BusService.
+     * This method is used to log tool requests and notify the system of the requested tool calls.
+     * The tool requests are transformed into tool call objects using the `createToolRequest` utility.
+     *
+     * @param {IToolRequest[]} request - An array of tool request objects, each containing details about the requested tools.
+     * @returns {Promise<void>} Resolves when the tool request is committed to history and the event is emitted.
+     */
+    async commitToolRequest(request) {
+        GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
+            this.params.logger.debug(`ClientAgent agentName=${this.params.agentName} clientId=${this.params.clientId} commitToolRequest`, { request });
+        this.params.onToolRequest &&
+            this.params.onToolRequest(this.params.clientId, this.params.agentName, request);
+        const tool_calls = request.map(createToolRequest);
+        await this.params.history.push({
+            role: "assistant",
+            agentName: this.params.agentName,
+            mode: "tool",
+            content: "",
+            tool_calls,
+        });
+        await this.params.bus.emit(this.params.clientId, {
+            type: "commit-tool-request",
+            source: "agent-bus",
+            input: {
+                request,
+            },
+            output: {},
+            context: {
+                agentName: this.params.agentName,
+            },
+            clientId: this.params.clientId,
+        });
+        return tool_calls.map(({ id }) => id);
+    }
     /**
      * Commits an assistant message to the history without triggering execution, notifying the system via BusService.
      * Useful for logging assistant responses, coordinated with HistoryConnectionService.
@@ -4666,6 +4759,16 @@ class ClientOperator {
             this.params.logger.debug(`ClientOperator agentName=${this.params.agentName} clientId=${this.params.clientId} commitSystemMessage - not supported`);
         return Promise.resolve();
     }
+    /**
+     * Commits tool request (not supported)
+     * @returns {Promise<string[]>}
+     */
+    commitToolRequest() {
+        console.warn(`ClientOperator: commitToolRequest should not be called for clientId=${this.params.clientId} agentName=${this.params.agentName}`);
+        GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
+            this.params.logger.debug(`ClientOperator agentName=${this.params.agentName} clientId=${this.params.clientId} commitToolRequest - not supported`);
+        return Promise.resolve([]);
+    }
     /**
      * Commits user message
      * @param {string} content - Message content
@@ -4730,7 +4833,7 @@ class ClientOperator {
     }
 }
 
-const METHOD_NAME$1l = "function.commit.commitToolOutput";
+const METHOD_NAME$1n = "function.commit.commitToolOutput";
 /**
  * Commits the output of a tool execution to the active agent in a swarm session.
  *
@@ -4750,19 +4853,19 @@ const METHOD_NAME$1l = "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$1l, {
+        swarm$1.loggerService.log(METHOD_NAME$1n, {
             toolId,
             content,
             clientId,
             agentName,
         });
     // Validate the agent, session, and swarm to ensure they exist and are accessible
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1l);
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1l);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1n);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1n);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1l);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1n);
     // Check if the specified agent is still the active agent in the swarm session
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1l, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1n, clientId, swarmName);
     if (currentAgentName !== agentName) {
         // Log a skip message if the agent has changed during the operation
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
@@ -4775,10 +4878,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$1l, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitToolOutput(toolId, content, METHOD_NAME$1n, clientId, swarmName);
 });
 
-const METHOD_NAME$1k = "function.target.execute";
+const METHOD_NAME$1m = "function.target.execute";
 /**
  * Sends a message to the active agent in a swarm session as if it originated from the client side.
  *
@@ -4800,19 +4903,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$1k, {
+        swarm$1.loggerService.log(METHOD_NAME$1m, {
             content,
             clientId,
             agentName,
             executionId,
         });
     // Validate the agent, session, and swarm
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1k);
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1k);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1m);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1m);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1k);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1m);
     // Check if the specified agent is still the active agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1k, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1m, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "execute" skipped due to the agent change', {
@@ -4831,7 +4934,7 @@ const execute = beginContext(async (content, clientId, agentName) => {
                 agentName,
                 swarmName,
             });
-            const result = await swarm$1.sessionPublicService.execute(content, "tool", METHOD_NAME$1k, clientId, swarmName);
+            const result = await swarm$1.sessionPublicService.execute(content, "tool", METHOD_NAME$1m, clientId, swarmName);
             isFinished = swarm$1.perfService.endExecution(executionId, clientId, result.length);
             swarm$1.busService.commitExecutionEnd(clientId, {
                 agentName,
@@ -4852,7 +4955,7 @@ const execute = beginContext(async (content, clientId, agentName) => {
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$1j = "function.commit.commitFlush";
+const METHOD_NAME$1l = "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.
@@ -4869,19 +4972,19 @@ const METHOD_NAME$1j = "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$1j, {
+        swarm$1.loggerService.log(METHOD_NAME$1l, {
             clientId,
             agentName,
         });
     // Validate the agent exists
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1j);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1l);
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1j);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1l);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1j);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1l);
     // Check if the current agent matches the provided agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1j, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1l, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "commitFlush" skipped due to the agent change', {
@@ -4892,10 +4995,10 @@ const commitFlush = beginContext(async (clientId, agentName) => {
         return;
     }
     // Commit the flush of agent history via SessionPublicService
-    await swarm$1.sessionPublicService.commitFlush(METHOD_NAME$1j, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitFlush(METHOD_NAME$1l, clientId, swarmName);
 });
 
-const METHOD_NAME$1i = "function.target.emit";
+const METHOD_NAME$1k = "function.target.emit";
 /**
  * Emits a string as model output without executing an incoming message, with agent activity validation.
  *
@@ -4915,18 +5018,18 @@ const METHOD_NAME$1i = "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$1i, {
+        swarm$1.loggerService.log(METHOD_NAME$1k, {
             content,
             clientId,
             agentName,
         });
     // Validate the agent, session, and swarm
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1i);
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1i);
+    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$1i);
+    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$1i, 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 "emit" skipped due to the agent change', {
@@ -4937,10 +5040,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$1i, clientId, swarmName);
+    return await swarm$1.sessionPublicService.emit(content, METHOD_NAME$1k, clientId, swarmName);
 });
 
-const METHOD_NAME$1h = "function.common.getAgentName";
+const METHOD_NAME$1j = "function.common.getAgentName";
 /**
  * Retrieves the name of the active agent for a given client session in a swarm.
  *
@@ -4958,19 +5061,19 @@ const METHOD_NAME$1h = "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$1h, {
+        swarm$1.loggerService.log(METHOD_NAME$1j, {
             clientId,
         });
     // Validate the session and swarm to ensure they exist and are accessible
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1h);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1j);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1h);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1j);
     // Retrieve the active agent name via the swarm public service
-    return await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1h, clientId, swarmName);
+    return await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1j, clientId, swarmName);
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$1g = "function.commit.commitStopTools";
+const METHOD_NAME$1i = "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.
@@ -4987,19 +5090,19 @@ const METHOD_NAME$1g = "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$1g, {
+        swarm$1.loggerService.log(METHOD_NAME$1i, {
             clientId,
             agentName,
         });
     // Validate the agent exists
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1g);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1i);
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1g);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1i);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1g);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1i);
     // Check if the current agent matches the provided agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1g, 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 "commitStopTools" skipped due to the agent change', {
@@ -5010,7 +5113,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$1g, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitStopTools(METHOD_NAME$1i, clientId, swarmName);
 });
 
 const METHOD_NAME_UPDATE$2 = "McpUtils.update";
@@ -5440,6 +5543,20 @@ class AgentConnectionService {
                 });
             return await this.getAgent(this.methodContextService.context.clientId, this.methodContextService.context.agentName).commitSystemMessage(message);
         };
+        /**
+         * Commits a tool request to the agent’s history.
+         * Delegates to ClientAgent.commitToolRequest, using context from MethodContextService, logging via LoggerService if GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO is true.
+         * Mirrors SessionPublicService’s commitToolRequest, supporting ClientAgent’s tool request handling and HistoryPublicService.
+         * @param {IToolRequest[]} request - An array of tool request objects to commit.
+         * @returns {Promise<string[]>} A promise resolving to the commit result, type determined by ClientAgent’s implementation.
+         */
+        this.commitToolRequest = async (request) => {
+            GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO &&
+                this.loggerService.info(`agentConnectionService commitToolRequest`, {
+                    request,
+                });
+            return await this.getAgent(this.methodContextService.context.clientId, this.methodContextService.context.agentName).commitToolRequest(request);
+        };
         /**
          * Commits an assistant message to the agent’s history.
          * Delegates to ClientAgent.commitAssistantMessage, using context from MethodContextService, logging via LoggerService if GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO is true.
@@ -5523,7 +5640,7 @@ class AgentConnectionService {
 }
 
 /** @private Constant defining the method name for logging purposes */
-const METHOD_NAME$1f = "function.common.getPayload";
+const METHOD_NAME$1h = "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.
@@ -5534,7 +5651,7 @@ const METHOD_NAME$1f = "function.common.getPayload";
  * console.log(payload); // { id: number } or null
  */
 const getPayload = () => {
-    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$1f);
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$1h);
     if (PayloadContextService.hasContext()) {
         const { payload } = swarm$1.payloadContextService.context;
         return payload;
@@ -5673,7 +5790,7 @@ class ClientHistory {
         }))
             .filter(({ content, tool_calls }) => !!content || !!tool_calls?.length)
             .filter(this._filterCondition)
-            .slice(-GLOBAL_CONFIG.CC_KEEP_MESSAGES);
+            .slice(-this.params.keepMessages);
         const assistantToolOutputCallSet = new Set(commonMessages
             .filter(({ tool_call_id }) => !!tool_call_id)
             .map(({ tool_call_id }) => tool_call_id));
@@ -5774,6 +5891,13 @@ class HistoryConnectionService {
          * @private
          */
         this.sessionValidationService = inject(TYPES.sessionValidationService);
+        /**
+         * Agent schema service instance, injected via DI, for managing agent schema-related operations.
+         * Used to validate and process agent schemas within the history connection service.
+         * @type {AgentSchemaService}
+         * @private
+         */
+        this.agentSchemaService = inject(TYPES.agentSchemaService);
         /**
          * Retrieves or creates a memoized ClientHistory instance for a given client and agent.
          * Uses functools-kit’s memoize to cache instances by a composite key (clientId-agentName), ensuring efficient reuse across calls.
@@ -5785,9 +5909,11 @@ class HistoryConnectionService {
          */
         this.getHistory = functoolsKit.memoize(([clientId, agentName]) => `${clientId}-${agentName}`, (clientId, agentName) => {
             this.sessionValidationService.addHistoryUsage(clientId, agentName);
+            const { keepMessages = GLOBAL_CONFIG.CC_KEEP_MESSAGES } = this.agentSchemaService.get(agentName);
             return new ClientHistory({
                 clientId,
                 agentName,
+                keepMessages,
                 bus: this.busService,
                 items: GLOBAL_CONFIG.CC_GET_AGENT_HISTORY_ADAPTER(clientId, agentName),
                 logger: this.loggerService,
@@ -6089,6 +6215,19 @@ class NoopAgent {
         console.error(message, context);
         return await this.defaultAgent.commitSystemMessage(content);
     }
+    /**
+     * Logs an attempt to commit a tool request for the missing agent and delegates to the default agent's commitToolRequest method.
+     * @param {IToolRequest[]} request - An array of tool requests to commit.
+     * @returns {Promise<void>} Resolves when the default agent's commitToolRequest method completes.
+     * @async
+     */
+    async commitToolRequest(request) {
+        const message = `called commitToolOutput on agent which not in the swarm clientId=${this.clientId} agentName=${this.agentName} swarmName=${this.swarmName}`;
+        const context = { request };
+        this.logger.log(message, context);
+        console.error(message, context);
+        return await this.defaultAgent.commitToolRequest(request);
+    }
     /**
      * Logs an attempt to commit a user message for the missing agent and delegates to the default agent's commitUserMessage method.
      * @param {string} content - The user message content to commit.
@@ -7192,6 +7331,34 @@ class ClientSession {
         });
         return result;
     }
+    /**
+     * Commits a tool request to the agent's history via the swarm’s agent (ClientAgent) and logs the action via BusService.
+     * Supports ToolSchemaService by linking tool requests to tool execution, integrating with ClientAgent’s history management.
+     *
+     * @param {IToolRequest[]} request - An array of tool requests to commit, typically representing tool execution details.
+     * @returns {Promise<string[]>} Resolves when the tool request is committed and the event is logged.
+     */
+    async commitToolRequest(request) {
+        GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
+            this.params.logger.debug(`ClientSession clientId=${this.params.clientId} commitToolRequest`, {
+                request,
+            });
+        const agent = await this.params.swarm.getAgent();
+        const result = await agent.commitToolRequest(request);
+        await this.params.bus.emit(this.params.clientId, {
+            type: "commit-tool-request",
+            source: "session-bus",
+            input: {
+                request,
+            },
+            output: {},
+            context: {
+                swarmName: this.params.swarmName,
+            },
+            clientId: this.params.clientId,
+        });
+        return result;
+    }
     /**
      * Commits a system message to the agent’s history via the swarm’s agent (ClientAgent), logging via BusService.
      * Supports system-level updates within the session, coordinated with ClientHistory.
@@ -7785,6 +7952,21 @@ class SessionConnectionService {
                 });
             return await this.getSession(this.methodContextService.context.clientId, this.methodContextService.context.swarmName).commitSystemMessage(message);
         };
+        /**
+         * Commits a tool request to the session’s history.
+         * Delegates to ClientSession.commitToolRequest, using context from MethodContextService, logging via LoggerService if GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO is true.
+         * Mirrors SessionPublicService’s commitToolRequest, supporting ClientAgent’s tool requests and HistoryPublicService integration.
+         *
+         * @param {IToolRequest[]} request - An array of tool requests to commit.
+         * @returns {Promise<string[]>} A promise resolving when the tool requests are committed.
+         */
+        this.commitToolRequest = async (request) => {
+            GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO &&
+                this.loggerService.info(`sessionConnectionService commitToolRequest`, {
+                    request,
+                });
+            return await this.getSession(this.methodContextService.context.clientId, this.methodContextService.context.swarmName).commitToolRequest(request);
+        };
         /**
          * Commits an assistant message to the session’s history.
          * Delegates to ClientSession.commitAssistantMessage, using context from MethodContextService, logging via LoggerService if GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO is true.
@@ -8069,6 +8251,39 @@ class AgentPublicService {
                 computeName: "",
             });
         };
+        /**
+         * Commits a tool request to the agent’s history.
+         * Wraps AgentConnectionService.commitToolRequest with MethodContextService, logging via LoggerService if GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO is true.
+         * Used for submitting tool requests, typically in scenarios where multiple tools are involved in agent operations.
+         *
+         * @param {IToolRequest[]} request - An array of tool requests to commit.
+         * @param {string} methodName - The method name for context and logging.
+         * @param {string} clientId - The client ID for session tracking.
+         * @param {AgentName} agentName - The agent name for identification.
+         * @returns {Promise<unknown>} A promise resolving to the commit result.
+         */
+        this.commitToolRequest = async (request, methodName, clientId, agentName) => {
+            GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO &&
+                this.loggerService.info("agentPublicService commitToolRequest", {
+                    methodName,
+                    request,
+                    clientId,
+                    agentName,
+                });
+            return await MethodContextService.runInContext(async () => {
+                return await this.agentConnectionService.commitToolRequest(request);
+            }, {
+                methodName,
+                clientId,
+                agentName,
+                policyName: "",
+                swarmName: "",
+                storageName: "",
+                stateName: "",
+                mcpName: "",
+                computeName: "",
+            });
+        };
         /**
          * Commits an assistant message to the agent’s history.
          * Wraps AgentConnectionService.commitAssistantMessage with MethodContextService, logging via LoggerService if GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO is true.
@@ -8720,6 +8935,39 @@ class SessionPublicService {
                 computeName: "",
             });
         };
+        /**
+         * Commits a tool request to the session’s history.
+         * Wraps SessionConnectionService.commitToolRequest with MethodContextService, logging via LoggerService if GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO is true.
+         * Supports ClientAgent’s tool execution requests, mirrored in AgentPublicService.
+         *
+         * @param {IToolRequest[]} request - The array of tool requests to commit.
+         * @param {string} methodName - The name of the method invoking the operation, used for logging and context.
+         * @param {string} clientId - The client ID for session tracking.
+         * @param {SwarmName} swarmName - The swarm name for context.
+         * @returns {Promise<void>} A promise resolving when the tool request is committed.
+         */
+        this.commitToolRequest = async (request, methodName, clientId, swarmName) => {
+            GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO &&
+                this.loggerService.info("sessionPublicService commitToolRequest", {
+                    methodName,
+                    request,
+                    clientId,
+                    swarmName,
+                });
+            return await MethodContextService.runInContext(async () => {
+                return await this.sessionConnectionService.commitToolRequest(request);
+            }, {
+                methodName,
+                clientId,
+                swarmName,
+                policyName: "",
+                agentName: "",
+                storageName: "",
+                stateName: "",
+                mcpName: "",
+                computeName: "",
+            });
+        };
         /**
          * Commits an assistant message to the session’s history.
          * Wraps SessionConnectionService.commitAssistantMessage with MethodContextService, logging via LoggerService if GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO is true.
@@ -17422,7 +17670,7 @@ const swarm = {
 init();
 var swarm$1 = swarm;
 
-const METHOD_NAME$1e = "cli.dumpDocs";
+const METHOD_NAME$1g = "cli.dumpDocs";
 /**
  * Dumps the documentation for the agents and swarms.
  *
@@ -17432,7 +17680,7 @@ const METHOD_NAME$1e = "cli.dumpDocs";
  */
 const dumpDocs = beginContext((prefix = "swarm", dirName = "./docs/chat", PlantUML) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$1e, {
+        swarm$1.loggerService.log(METHOD_NAME$1g, {
             dirName,
         });
     if (PlantUML) {
@@ -17442,10 +17690,10 @@ const dumpDocs = beginContext((prefix = "swarm", dirName = "./docs/chat", PlantU
     }
     swarm$1.agentValidationService
         .getAgentList()
-        .forEach((agentName) => swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1e));
+        .forEach((agentName) => swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1g));
     swarm$1.swarmValidationService
         .getSwarmList()
-        .forEach((swarmName) => swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1e));
+        .forEach((swarmName) => swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1g));
     swarm$1.agentValidationService.getAgentList().forEach((agentName) => {
         const { dependsOn } = swarm$1.agentSchemaService.get(agentName);
         if (!dependsOn) {
@@ -17455,7 +17703,7 @@ const dumpDocs = beginContext((prefix = "swarm", dirName = "./docs/chat", PlantU
     return swarm$1.docService.dumpDocs(prefix, dirName);
 });
 
-const METHOD_NAME$1d = "cli.dumpAgent";
+const METHOD_NAME$1f = "cli.dumpAgent";
 /**
  * Dumps the agent information into PlantUML format.
  *
@@ -17464,14 +17712,14 @@ const METHOD_NAME$1d = "cli.dumpAgent";
  */
 const dumpAgent = beginContext((agentName, { withSubtree = false } = {}) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$1d, {
+        swarm$1.loggerService.log(METHOD_NAME$1f, {
             agentName,
         });
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1d);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1f);
     return swarm$1.agentMetaService.toUML(agentName, withSubtree);
 });
 
-const METHOD_NAME$1c = "cli.dumpSwarm";
+const METHOD_NAME$1e = "cli.dumpSwarm";
 /**
  * Dumps the swarm information into PlantUML format.
  *
@@ -17480,14 +17728,14 @@ const METHOD_NAME$1c = "cli.dumpSwarm";
  */
 const dumpSwarm = beginContext((swarmName) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$1c, {
+        swarm$1.loggerService.log(METHOD_NAME$1e, {
             swarmName,
         });
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1c);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1e);
     return swarm$1.swarmMetaService.toUML(swarmName);
 });
 
-const METHOD_NAME$1b = "cli.dumpPerfomance";
+const METHOD_NAME$1d = "cli.dumpPerfomance";
 const METHOD_NAME_INTERNAL$1 = "cli.dumpPerfomance.internal";
 const METHOD_NAME_INTERVAL = "cli.dumpPerfomance.interval";
 /**
@@ -17506,7 +17754,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$1b);
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$1d);
     await dumpPerfomanceInternal(dirName);
 };
 /**
@@ -17564,7 +17812,7 @@ const listenExecutionEvent = beginContext((clientId, fn) => {
     return swarm$1.busService.subscribe(clientId, "execution-bus", functoolsKit.queued(async (e) => await fn(e)));
 });
 
-const METHOD_NAME$1a = "cli.dumpClientPerformance";
+const METHOD_NAME$1c = "cli.dumpClientPerformance";
 const METHOD_NAME_INTERNAL = "cli.dumpClientPerformance.internal";
 const METHOD_NAME_EXECUTE = "cli.dumpClientPerformance.execute";
 /**
@@ -17588,7 +17836,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$1a);
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$1c);
     await dumpClientPerformanceInternal(clientId, dirName);
 };
 /**
@@ -17609,7 +17857,7 @@ dumpClientPerformance.runAfterExecute = beginContext(async (dirName = "./logs/cl
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$19 = "function.commit.commitFlushForce";
+const METHOD_NAME$1b = "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.
@@ -17627,20 +17875,20 @@ const METHOD_NAME$19 = "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$19, {
+        swarm$1.loggerService.log(METHOD_NAME$1b, {
             clientId,
-            METHOD_NAME: METHOD_NAME$19,
+            METHOD_NAME: METHOD_NAME$1b,
         });
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$19);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1b);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$19);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1b);
     // Commit the flush of agent history via SessionPublicService without agent checks
-    await swarm$1.sessionPublicService.commitFlush(METHOD_NAME$19, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitFlush(METHOD_NAME$1b, clientId, swarmName);
 });
 
-const METHOD_NAME$18 = "function.commit.commitToolOutputForce";
+const METHOD_NAME$1a = "function.commit.commitToolOutputForce";
 /**
  * Commits the output of a tool execution to the active agent in a swarm session without checking the active agent.
  *
@@ -17659,24 +17907,24 @@ const METHOD_NAME$18 = "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$18, {
+        swarm$1.loggerService.log(METHOD_NAME$1a, {
             toolId,
             content,
             clientId,
         });
     // Validate the session and swarm to ensure they exist and are accessible
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$18);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1a);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$18);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1a);
     // 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$18, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitToolOutput(toolId, content, METHOD_NAME$1a, 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$17 = "function.common.hasNavigation";
+const METHOD_NAME$19 = "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.
@@ -17687,16 +17935,16 @@ const METHOD_NAME$17 = "function.common.hasNavigation";
  */
 const hasNavigation = async (clientId, agentName) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$17, { clientId });
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$17);
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$17);
+        swarm$1.loggerService.log(METHOD_NAME$19, { clientId });
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$19);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$19);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     return swarm$1.navigationValidationService
         .getNavigationRoute(clientId, swarmName)
         .has(agentName);
 };
 
-const METHOD_NAME$16 = "function.history.getRawHistory";
+const METHOD_NAME$18 = "function.history.getRawHistory";
 /**
  * Retrieves the raw, unmodified history for a given client session.
  *
@@ -17713,10 +17961,10 @@ const METHOD_NAME$16 = "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$16) => {
+const getRawHistory = beginContext(async (clientId, methodName = METHOD_NAME$18) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$16, {
+        swarm$1.loggerService.log(METHOD_NAME$18, {
             clientId,
         });
     // Validate the session and swarm
@@ -17729,7 +17977,7 @@ const getRawHistory = beginContext(async (clientId, methodName = METHOD_NAME$16)
     return [...history];
 });
 
-const METHOD_NAME$15 = "function.history.getLastUserMessage";
+const METHOD_NAME$17 = "function.history.getLastUserMessage";
 /**
  * Retrieves the content of the most recent user message from a client's session history.
  *
@@ -17747,18 +17995,18 @@ const METHOD_NAME$15 = "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$15, {
+        swarm$1.loggerService.log(METHOD_NAME$17, {
             clientId,
         });
     // Fetch raw history and find the last user message
-    const history = await getRawHistory(clientId, METHOD_NAME$15);
+    const history = await getRawHistory(clientId, METHOD_NAME$17);
     const last = history.findLast(({ role, mode }) => role === "user" && mode === "user");
     return last?.content ? last.content : null;
 });
 
 const disposeSubject = new functoolsKit.Subject();
 
-const METHOD_NAME$14 = "function.navigate.changeToDefaultAgent";
+const METHOD_NAME$16 = "function.navigate.changeToDefaultAgent";
 /**
  * Creates a change agent function with time-to-live (TTL) and queuing capabilities for switching to the default agent.
  *
@@ -17781,7 +18029,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$14, clientId, swarmName);
+        const agentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$16, 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));
@@ -17819,23 +18067,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$14, {
+        swarm$1.loggerService.log(METHOD_NAME$16, {
             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$14);
-        swarm$1.agentValidationService.validate(agentName, METHOD_NAME$14);
+        swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$16);
+        swarm$1.agentValidationService.validate(agentName, METHOD_NAME$16);
     }
     // Execute the agent change with TTL and queuing
     const run = await createChangeToDefaultAgent(clientId);
     createGc$3();
-    return await run(METHOD_NAME$14, agentName, swarmName);
+    return await run(METHOD_NAME$16, agentName, swarmName);
 });
 
-const METHOD_NAME$13 = "function.target.emitForce";
+const METHOD_NAME$15 = "function.target.emitForce";
 /**
  * Emits a string as model output without executing an incoming message or checking the active agent.
  *
@@ -17854,19 +18102,19 @@ const METHOD_NAME$13 = "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$13, {
+        swarm$1.loggerService.log(METHOD_NAME$15, {
             content,
             clientId,
         });
     // Validate the session and swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$13);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$15);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$13);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$15);
     // Emit the content directly via the session public service
-    return await swarm$1.sessionPublicService.emit(content, METHOD_NAME$13, clientId, swarmName);
+    return await swarm$1.sessionPublicService.emit(content, METHOD_NAME$15, clientId, swarmName);
 });
 
-const METHOD_NAME$12 = "function.target.executeForce";
+const METHOD_NAME$14 = "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.
  *
@@ -17887,22 +18135,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$12, {
+        swarm$1.loggerService.log(METHOD_NAME$14, {
             content,
             clientId,
             executionId,
         });
     // Validate the session and swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$12);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$14);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$12);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$14);
     // 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$12, clientId, swarmName);
+            const result = await swarm$1.sessionPublicService.execute(content, "tool", METHOD_NAME$14, clientId, swarmName);
             isFinished = swarm$1.perfService.endExecution(executionId, clientId, result.length);
             swarm$1.busService.commitExecutionEnd(clientId, { swarmName });
             return result;
@@ -17919,7 +18167,7 @@ const executeForce = beginContext(async (content, clientId) => {
     });
 });
 
-const METHOD_NAME$11 = "function.template.navigateToTriageAgent";
+const METHOD_NAME$13 = "function.template.navigateToTriageAgent";
 /**
  * Will send tool output directly to the model without any additions
  */
@@ -17970,7 +18218,7 @@ const createNavigateToTriageAgent = ({ flushMessage, lastMessage: lastMessageFn
      */
     return beginContext(async (toolId, clientId) => {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-            swarm$1.loggerService.log(METHOD_NAME$11, {
+            swarm$1.loggerService.log(METHOD_NAME$13, {
                 clientId,
                 toolId,
             });
@@ -18002,7 +18250,7 @@ const createNavigateToTriageAgent = ({ flushMessage, lastMessage: lastMessageFn
     });
 };
 
-const METHOD_NAME$10 = "function.navigate.changeToAgent";
+const METHOD_NAME$12 = "function.navigate.changeToAgent";
 /**
  * Creates a change agent function with time-to-live (TTL) and queuing capabilities.
  *
@@ -18026,7 +18274,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$10, clientId, swarmName);
+        const agentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$12, clientId, swarmName);
         await swarm$1.agentPublicService.dispose(methodName, clientId, agentName);
         await swarm$1.historyPublicService.dispose(methodName, clientId, agentName);
         await swarm$1.swarmPublicService.setAgentRef(methodName, clientId, swarmName, agentName, await swarm$1.agentPublicService.createAgentRef(methodName, clientId, agentName));
@@ -18065,16 +18313,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$10, {
+        swarm$1.loggerService.log(METHOD_NAME$12, {
             agentName,
             clientId,
         });
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     {
         // Validate session, agent, and dependencies
-        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);
+        swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$12);
+        swarm$1.agentValidationService.validate(agentName, METHOD_NAME$12);
+        const activeAgent = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$12, clientId, swarmName);
         if (!swarm$1.agentValidationService.hasDependency(activeAgent, agentName)) {
             console.error(`agent-swarm missing dependency detected for activeAgent=${activeAgent} dependencyAgent=${agentName}`);
         }
@@ -18092,10 +18340,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$10, agentName, swarmName);
+    return await run(METHOD_NAME$12, agentName, swarmName);
 });
 
-const METHOD_NAME$$ = "function.template.navigateToAgent";
+const METHOD_NAME$11 = "function.template.navigateToAgent";
 /**
  * Will send tool output directly to the model without any additions
  */
@@ -18161,7 +18409,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$11, {
                 clientId,
                 toolId,
             });
@@ -18194,7 +18442,7 @@ const createNavigateToAgent = ({ executeMessage = DEFAULT_EXECUTE_MESSAGE, emitM
     });
 };
 
-const METHOD_NAME$_ = "function.setup.addTool";
+const METHOD_NAME$10 = "function.setup.addTool";
 /**
  * Adds a new tool to the tool registry for use by agents in the swarm system.
  *
@@ -18216,7 +18464,7 @@ const METHOD_NAME$_ = "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$_, {
+        swarm$1.loggerService.log(METHOD_NAME$10, {
             toolSchema,
         });
     // Register the tool in the validation and schema services
@@ -18230,7 +18478,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$Z = "function.alias.addAgentNavigation";
+const METHOD_NAME$$ = "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.
@@ -18244,7 +18492,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$Z);
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$$);
     const navigate = createNavigateToAgent(navigateProps);
     return addTool({
         toolName,
@@ -18273,7 +18521,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$Y = "function.alias.addTriageNavigation";
+const METHOD_NAME$_ = "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.
@@ -18286,7 +18534,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$Y);
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$_);
     const navigate = createNavigateToTriageAgent(navigateProps);
     return addTool({
         toolName,
@@ -18312,7 +18560,7 @@ const addTriageNavigation = beginContext(({ toolName, docNote, description, skip
 });
 
 /** @constant {string} METHOD_NAME - The name of the method used for logging */
-const METHOD_NAME$X = "function.setup.addWiki";
+const METHOD_NAME$Z = "function.setup.addWiki";
 /**
  * Adds a wiki schema to the system
  * @function addWiki
@@ -18321,7 +18569,7 @@ const METHOD_NAME$X = "function.setup.addWiki";
  */
 const addWiki = beginContext((wikiSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$X, {
+        swarm$1.loggerService.log(METHOD_NAME$Z, {
             wikiSchema,
         });
     swarm$1.wikiValidationService.addWiki(wikiSchema.wikiName, wikiSchema);
@@ -18329,7 +18577,7 @@ const addWiki = beginContext((wikiSchema) => {
     return wikiSchema.wikiName;
 });
 
-const METHOD_NAME$W = "function.setup.addAgent";
+const METHOD_NAME$Y = "function.setup.addAgent";
 /**
  * Adds a new agent to the agent registry for use within the swarm system.
  *
@@ -18349,7 +18597,7 @@ const METHOD_NAME$W = "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$W, {
+        swarm$1.loggerService.log(METHOD_NAME$Y, {
             agentSchema,
         });
     // Register the agent in the validation and schema services
@@ -18359,7 +18607,7 @@ const addAgent = beginContext((agentSchema) => {
     return agentSchema.agentName;
 });
 
-const METHOD_NAME$V = "function.setup.addCompletion";
+const METHOD_NAME$X = "function.setup.addCompletion";
 /**
  * Adds a completion engine to the registry for use by agents in the swarm system.
  *
@@ -18379,7 +18627,7 @@ const METHOD_NAME$V = "function.setup.addCompletion";
 const addCompletion = beginContext((completionSchema) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$V, {
+        swarm$1.loggerService.log(METHOD_NAME$X, {
             completionSchema,
         });
     // Register the completion in the validation and schema services
@@ -18389,7 +18637,7 @@ const addCompletion = beginContext((completionSchema) => {
     return completionSchema.completionName;
 });
 
-const METHOD_NAME$U = "function.setup.addSwarm";
+const METHOD_NAME$W = "function.setup.addSwarm";
 /**
  * Adds a new swarm to the system for managing client sessions.
  *
@@ -18409,7 +18657,7 @@ const METHOD_NAME$U = "function.setup.addSwarm";
 const addSwarm = beginContext((swarmSchema) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$U, {
+        swarm$1.loggerService.log(METHOD_NAME$W, {
             swarmSchema,
         });
     // Register the swarm in the validation and schema services
@@ -18419,7 +18667,7 @@ const addSwarm = beginContext((swarmSchema) => {
     return swarmSchema.swarmName;
 });
 
-const METHOD_NAME$T = "function.setup.addMCP";
+const METHOD_NAME$V = "function.setup.addMCP";
 /**
  * Registers a new MCP (Model Context Protocol) schema in the system.
  * @param mcpSchema - The MCP schema to register.
@@ -18427,7 +18675,7 @@ const METHOD_NAME$T = "function.setup.addMCP";
  */
 const addMCP = beginContext((mcpSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$T, {
+        swarm$1.loggerService.log(METHOD_NAME$V, {
             mcpSchema,
         });
     swarm$1.mcpValidationService.addMCP(mcpSchema.mcpName, mcpSchema);
@@ -18435,7 +18683,7 @@ const addMCP = beginContext((mcpSchema) => {
     return mcpSchema.mcpName;
 });
 
-const METHOD_NAME$S = "function.setup.addState";
+const METHOD_NAME$U = "function.setup.addState";
 /**
  * Adds a new state to the state registry for use within the swarm system.
  *
@@ -18457,7 +18705,7 @@ const METHOD_NAME$S = "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$S, {
+        swarm$1.loggerService.log(METHOD_NAME$U, {
             stateSchema,
         });
     // Register the policy with StateValidationService for runtime validation
@@ -18474,7 +18722,7 @@ const addState = beginContext((stateSchema) => {
     return stateSchema.stateName;
 });
 
-const METHOD_NAME$R = "function.setup.addEmbedding";
+const METHOD_NAME$T = "function.setup.addEmbedding";
 /**
  * Adds a new embedding engine to the embedding registry for use within the swarm system.
  *
@@ -18494,7 +18742,7 @@ const METHOD_NAME$R = "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$R, {
+        swarm$1.loggerService.log(METHOD_NAME$T, {
             embeddingSchema,
         });
     // Register the embedding in the validation and schema services
@@ -18504,7 +18752,7 @@ const addEmbedding = beginContext((embeddingSchema) => {
     return embeddingSchema.embeddingName;
 });
 
-const METHOD_NAME$Q = "function.setup.addStorage";
+const METHOD_NAME$S = "function.setup.addStorage";
 /**
  * Adds a new storage engine to the storage registry for use within the swarm system.
  *
@@ -18526,7 +18774,7 @@ const METHOD_NAME$Q = "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$Q, {
+        swarm$1.loggerService.log(METHOD_NAME$S, {
             storageSchema,
         });
     // Register the storage in the validation and schema services
@@ -18543,7 +18791,7 @@ const addStorage = beginContext((storageSchema) => {
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$P = "function.setup.addPolicy";
+const METHOD_NAME$R = "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.
@@ -18559,7 +18807,7 @@ const METHOD_NAME$P = "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$P, {
+        swarm$1.loggerService.log(METHOD_NAME$R, {
             policySchema,
         });
     // Register the policy with PolicyValidationService for runtime validation
@@ -18600,7 +18848,7 @@ const addCompute = beginContext((computeSchema) => {
  * @description Method name for the addPipeline operation.
  * @private
  */
-const METHOD_NAME$O = "function.setup.addPipeline";
+const METHOD_NAME$Q = "function.setup.addPipeline";
 /**
  * @function addPipeline
  * @description Registers a pipeline schema, validates it, and adds it to the pipeline schema service.
@@ -18610,7 +18858,7 @@ const METHOD_NAME$O = "function.setup.addPipeline";
  */
 const addPipeline = beginContext((pipelineSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$O, {
+        swarm$1.loggerService.log(METHOD_NAME$Q, {
             pipelineSchema,
         });
     swarm$1.pipelineValidationService.addPipeline(pipelineSchema.pipelineName, pipelineSchema);
@@ -18618,7 +18866,7 @@ const addPipeline = beginContext((pipelineSchema) => {
     return pipelineSchema.pipelineName;
 });
 
-const METHOD_NAME$N = "function.test.overrideAgent";
+const METHOD_NAME$P = "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.
@@ -18642,14 +18890,14 @@ const METHOD_NAME$N = "function.test.overrideAgent";
  */
 const overrideAgent = beginContext((agentSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$N, {
+        swarm$1.loggerService.log(METHOD_NAME$P, {
             agentSchema,
         });
     swarm$1.agentSchemaService.get(agentSchema.agentName);
     return swarm$1.agentSchemaService.override(agentSchema.agentName, agentSchema);
 });
 
-const METHOD_NAME$M = "function.test.overrideCompletion";
+const METHOD_NAME$O = "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.
@@ -18673,13 +18921,13 @@ const METHOD_NAME$M = "function.test.overrideCompletion";
  */
 const overrideCompletion = beginContext((completionSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$M, {
+        swarm$1.loggerService.log(METHOD_NAME$O, {
             completionSchema,
         });
     return swarm$1.completionSchemaService.override(completionSchema.completionName, completionSchema);
 });
 
-const METHOD_NAME$L = "function.test.overrideEmbeding";
+const METHOD_NAME$N = "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.
@@ -18705,13 +18953,13 @@ const METHOD_NAME$L = "function.test.overrideEmbeding";
  */
 const overrideEmbeding = beginContext((embeddingSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$L, {
+        swarm$1.loggerService.log(METHOD_NAME$N, {
             embeddingSchema,
         });
     return swarm$1.embeddingSchemaService.override(embeddingSchema.embeddingName, embeddingSchema);
 });
 
-const METHOD_NAME$K = "function.test.overridePolicy";
+const METHOD_NAME$M = "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.
@@ -18735,13 +18983,13 @@ const METHOD_NAME$K = "function.test.overridePolicy";
  */
 const overridePolicy = beginContext((policySchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$K, {
+        swarm$1.loggerService.log(METHOD_NAME$M, {
             policySchema,
         });
     return swarm$1.policySchemaService.override(policySchema.policyName, policySchema);
 });
 
-const METHOD_NAME$J = "function.test.overrideState";
+const METHOD_NAME$L = "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.
@@ -18766,13 +19014,13 @@ const METHOD_NAME$J = "function.test.overrideState";
  */
 const overrideState = beginContext((stateSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$J, {
+        swarm$1.loggerService.log(METHOD_NAME$L, {
             stateSchema,
         });
     return swarm$1.stateSchemaService.override(stateSchema.stateName, stateSchema);
 });
 
-const METHOD_NAME$I = "function.test.overrideStorage";
+const METHOD_NAME$K = "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.
@@ -18798,13 +19046,13 @@ const METHOD_NAME$I = "function.test.overrideStorage";
  */
 const overrideStorage = beginContext((storageSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$I, {
+        swarm$1.loggerService.log(METHOD_NAME$K, {
             storageSchema,
         });
     return swarm$1.storageSchemaService.override(storageSchema.storageName, storageSchema);
 });
 
-const METHOD_NAME$H = "function.test.overrideSwarm";
+const METHOD_NAME$J = "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.
@@ -18828,13 +19076,13 @@ const METHOD_NAME$H = "function.test.overrideSwarm";
  */
 const overrideSwarm = beginContext((swarmSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$H, {
+        swarm$1.loggerService.log(METHOD_NAME$J, {
             swarmSchema,
         });
     return swarm$1.swarmSchemaService.override(swarmSchema.swarmName, swarmSchema);
 });
 
-const METHOD_NAME$G = "function.test.overrideTool";
+const METHOD_NAME$I = "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.
@@ -18858,13 +19106,13 @@ const METHOD_NAME$G = "function.test.overrideTool";
  */
 const overrideTool = beginContext((toolSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$G, {
+        swarm$1.loggerService.log(METHOD_NAME$I, {
             toolSchema,
         });
     return swarm$1.toolSchemaService.override(toolSchema.toolName, toolSchema);
 });
 
-const METHOD_NAME$F = "function.test.overrideMCP";
+const METHOD_NAME$H = "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.
@@ -18872,13 +19120,13 @@ const METHOD_NAME$F = "function.test.overrideMCP";
  */
 const overrideMCP = beginContext((mcpSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$F, {
+        swarm$1.loggerService.log(METHOD_NAME$H, {
             mcpSchema,
         });
     return swarm$1.mcpSchemaService.override(mcpSchema.mcpName, mcpSchema);
 });
 
-const METHOD_NAME$E = "function.test.overrideWiki";
+const METHOD_NAME$G = "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.
@@ -18902,7 +19150,7 @@ const METHOD_NAME$E = "function.test.overrideWiki";
  */
 const overrideWiki = beginContext((wikiSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$E, {
+        swarm$1.loggerService.log(METHOD_NAME$G, {
             wikiSchema,
         });
     return swarm$1.wikiSchemaService.override(wikiSchema.wikiName, wikiSchema);
@@ -18917,7 +19165,7 @@ const overrideWiki = beginContext((wikiSchema) => {
  * @description Method name for the overrideCompute operation.
  * @private
  */
-const METHOD_NAME$D = "function.test.overrideCompute";
+const METHOD_NAME$F = "function.test.overrideCompute";
 /**
  * @function overrideCompute
  * @description Overrides an existing compute schema with provided partial updates.
@@ -18926,7 +19174,7 @@ const METHOD_NAME$D = "function.test.overrideCompute";
  */
 const overrideCompute = beginContext((computeSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$D, {
+        swarm$1.loggerService.log(METHOD_NAME$F, {
             computeSchema,
         });
     return swarm$1.computeSchemaService.override(computeSchema.computeName, computeSchema);
@@ -18941,7 +19189,7 @@ const overrideCompute = beginContext((computeSchema) => {
  * @description Method name for the overridePipeline operation.
  * @private
  */
-const METHOD_NAME$C = "function.test.overridePipeline";
+const METHOD_NAME$E = "function.test.overridePipeline";
 /**
  * @function overridePipeline
  * @description Overrides an existing pipeline schema with provided partial updates.
@@ -18951,13 +19199,13 @@ const METHOD_NAME$C = "function.test.overridePipeline";
  */
 const overridePipeline = beginContext((pipelineSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$C, {
+        swarm$1.loggerService.log(METHOD_NAME$E, {
             pipelineSchema,
         });
     return swarm$1.pipelineSchemaService.override(pipelineSchema.pipelineName, pipelineSchema);
 });
 
-const METHOD_NAME$B = "function.other.markOnline";
+const METHOD_NAME$D = "function.other.markOnline";
 /**
  * Marks a client as online in the specified swarm.
  *
@@ -18969,16 +19217,16 @@ const METHOD_NAME$B = "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$B, {
+        swarm.loggerService.log(METHOD_NAME$D, {
             clientId,
         });
     // Validate the swarm name
-    swarm.swarmValidationService.validate(swarmName, METHOD_NAME$B);
+    swarm.swarmValidationService.validate(swarmName, METHOD_NAME$D);
     // Run the operation in the method context
     return await MethodContextService.runInContext(async () => {
-        await swarm.aliveService.markOnline(clientId, swarmName, METHOD_NAME$B);
+        await swarm.aliveService.markOnline(clientId, swarmName, METHOD_NAME$D);
     }, {
-        methodName: METHOD_NAME$B,
+        methodName: METHOD_NAME$D,
         agentName: "",
         policyName: "",
         stateName: "",
@@ -18990,7 +19238,7 @@ const markOnline = async (clientId, swarmName) => {
     });
 };
 
-const METHOD_NAME$A = "function.other.markOffline";
+const METHOD_NAME$C = "function.other.markOffline";
 /**
  * Marks a client as offline in the specified swarm.
  *
@@ -19005,14 +19253,14 @@ const METHOD_NAME$A = "function.other.markOffline";
  */
 const markOffline = async (clientId, swarmName) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm.loggerService.log(METHOD_NAME$A, {
+        swarm.loggerService.log(METHOD_NAME$C, {
             clientId,
         });
-    swarm.swarmValidationService.validate(swarmName, METHOD_NAME$A);
+    swarm.swarmValidationService.validate(swarmName, METHOD_NAME$C);
     return await MethodContextService.runInContext(async () => {
-        await swarm.aliveService.markOffline(clientId, swarmName, METHOD_NAME$A);
+        await swarm.aliveService.markOffline(clientId, swarmName, METHOD_NAME$C);
     }, {
-        methodName: METHOD_NAME$A,
+        methodName: METHOD_NAME$C,
         agentName: "",
         policyName: "",
         stateName: "",
@@ -19025,7 +19273,7 @@ const markOffline = async (clientId, swarmName) => {
 };
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$z = "function.commit.commitSystemMessage";
+const METHOD_NAME$B = "function.commit.commitSystemMessage";
 /**
  * Commits a system-generated message to the active agent in the swarm system.
  * Validates the agent, session, and swarm, ensuring the current agent matches the provided agent before committing the message.
@@ -19044,20 +19292,20 @@ const METHOD_NAME$z = "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$z, {
+        swarm$1.loggerService.log(METHOD_NAME$B, {
             content,
             clientId,
             agentName,
         });
     // Validate the agent exists
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$z);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$B);
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$z);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$B);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$z);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$B);
     // Check if the current agent matches the provided agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$z, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$B, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "commitSystemMessage" skipped due to the agent change', {
@@ -19068,10 +19316,10 @@ const commitSystemMessage = beginContext(async (content, clientId, agentName) =>
         return;
     }
     // Commit the system message via SessionPublicService
-    await swarm$1.sessionPublicService.commitSystemMessage(content, METHOD_NAME$z, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitSystemMessage(content, METHOD_NAME$B, clientId, swarmName);
 });
 
-const METHOD_NAME$y = "function.commit.commitSystemMessage";
+const METHOD_NAME$A = "function.commit.commitSystemMessage";
 /**
  * Commits a user message to the active agent's history in a swarm session without triggering a response.
  *
@@ -19090,19 +19338,19 @@ const METHOD_NAME$y = "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$y, {
+        swarm$1.loggerService.log(METHOD_NAME$A, {
             content,
             clientId,
             agentName,
             mode,
         });
     // Validate the agent, session, and swarm to ensure they exist and are accessible
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$y);
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$y);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$A);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$A);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$y);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$A);
     // Check if the specified agent is still the active agent in the swarm session
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$y, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$A, clientId, swarmName);
     if (currentAgentName !== agentName) {
         // Log a skip message if the agent has changed during the operation
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
@@ -19115,18 +19363,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$y, clientId, swarmName);
+            await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$A, 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$y, clientId, swarmName);
+    return await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$A, clientId, swarmName);
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$x = "function.commit.commitSystemMessageForce";
+const METHOD_NAME$z = "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.
@@ -19145,20 +19393,20 @@ const METHOD_NAME$x = "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$x, {
+        swarm$1.loggerService.log(METHOD_NAME$z, {
             content,
             clientId,
         });
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$x);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$z);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$x);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$z);
     // Commit the system message via SessionPublicService without agent checks
-    await swarm$1.sessionPublicService.commitSystemMessage(content, METHOD_NAME$x, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitSystemMessage(content, METHOD_NAME$z, clientId, swarmName);
 });
 
-const METHOD_NAME$w = "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 and without checking the active agent.
  *
@@ -19176,29 +19424,29 @@ const METHOD_NAME$w = "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$w, {
+        swarm$1.loggerService.log(METHOD_NAME$y, {
             content,
             clientId,
             mode,
         });
     // Validate the session and swarm to ensure they exist and are accessible
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$w);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$y);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$w);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$y);
     if (payload) {
         return await PayloadContextService.runInContext(async () => {
-            await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$w, 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 without checking the active agent
-    return await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$w, 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$v = "function.commit.commitAssistantMessage";
+const METHOD_NAME$x = "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.
@@ -19216,20 +19464,20 @@ const METHOD_NAME$v = "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$v, {
+        swarm$1.loggerService.log(METHOD_NAME$x, {
             content,
             clientId,
             agentName,
         });
     // Validate the agent exists
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$v);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$x);
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$v);
+    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$v);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$x);
     // Check if the current agent matches the provided agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$v, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$x, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "commitAssistantMessage" skipped due to the agent change', {
@@ -19240,11 +19488,11 @@ const commitAssistantMessage = beginContext(async (content, clientId, agentName)
         return;
     }
     // Commit the assistant message via SessionPublicService
-    await swarm$1.sessionPublicService.commitAssistantMessage(content, METHOD_NAME$v, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitAssistantMessage(content, METHOD_NAME$x, clientId, swarmName);
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$u = "function.commit.commitAssistantMessageForce";
+const METHOD_NAME$w = "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.
@@ -19263,21 +19511,21 @@ const METHOD_NAME$u = "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$u, {
+        swarm$1.loggerService.log(METHOD_NAME$w, {
             content,
             clientId,
         });
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$u);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$w);
     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$w);
     // Commit the assistant message via SessionPublicService without agent checks
-    await swarm$1.sessionPublicService.commitAssistantMessage(content, METHOD_NAME$u, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitAssistantMessage(content, METHOD_NAME$w, clientId, swarmName);
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$t = "function.commit.cancelOutput";
+const METHOD_NAME$v = "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.
@@ -19293,19 +19541,19 @@ const METHOD_NAME$t = "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$t, {
+        swarm$1.loggerService.log(METHOD_NAME$v, {
             clientId,
             agentName,
         });
     // Validate the agent exists
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$t);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$v);
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$t);
+    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$t);
+    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$t, 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 "cancelOutput" skipped due to the agent change', {
@@ -19316,11 +19564,11 @@ const cancelOutput = beginContext(async (clientId, agentName) => {
         return;
     }
     // Perform the output cancellation via SwarmPublicService
-    await swarm$1.swarmPublicService.cancelOutput(METHOD_NAME$t, clientId, swarmName);
+    await swarm$1.swarmPublicService.cancelOutput(METHOD_NAME$v, clientId, swarmName);
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$s = "function.commit.cancelOutputForce";
+const METHOD_NAME$u = "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.
@@ -19337,20 +19585,20 @@ const METHOD_NAME$s = "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$s, {
+        swarm$1.loggerService.log(METHOD_NAME$u, {
             clientId,
         });
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$s);
+    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$s);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$u);
     // Perform the output cancellation via SwarmPublicService without agent checks
-    await swarm$1.swarmPublicService.cancelOutput(METHOD_NAME$s, clientId, swarmName);
+    await swarm$1.swarmPublicService.cancelOutput(METHOD_NAME$u, clientId, swarmName);
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$r = "function.commit.commitStopToolsForce";
+const METHOD_NAME$t = "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.
@@ -19368,17 +19616,82 @@ const METHOD_NAME$r = "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$r, {
+        swarm$1.loggerService.log(METHOD_NAME$t, {
             clientId,
-            METHOD_NAME: METHOD_NAME$r,
+            METHOD_NAME: METHOD_NAME$t,
         });
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$r);
+    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$r);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$t);
     // Commit the stop of the next tool execution via SessionPublicService without agent checks
-    await swarm$1.sessionPublicService.commitStopTools(METHOD_NAME$r, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitStopTools(METHOD_NAME$t, clientId, swarmName);
+});
+
+const METHOD_NAME$s = "function.commit.commitToolRequest";
+/**
+ * Commits a tool request 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 request.
+ * Runs within a beginContext wrapper for execution context management, logging operations via LoggerService.
+ * Integrates with AgentValidationService (agent validation), SessionValidationService (session and swarm retrieval),
+ * SwarmValidationService (swarm validation), SwarmPublicService (agent retrieval), SessionPublicService (tool request committing),
+ * and LoggerService (logging). Complements functions like commitSystemMessage by handling tool requests rather than system messages.
+ *
+ * @param {IToolRequest | IToolRequest[]} request - The tool request(s) to commit, either as a single request or an array of requests.
+ * @param {string} clientId - The ID of the client associated with the session, validated against active sessions.
+ * @param {string} agentName - The name of the agent to commit the request for, validated against registered agents.
+ * @returns {Promise<string[] | null>} A promise that resolves with an array of results if the request is committed, or `null` if skipped (e.g., agent mismatch).
+ * @throws {Error} If agent, session, or swarm validation fails, propagated from respective validation services.
+ */
+const commitToolRequest = beginContext(async (request, clientId, agentName) => {
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
+        swarm$1.loggerService.log(METHOD_NAME$s, {
+            request,
+            clientId,
+            agentName,
+        });
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$s);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$s);
+    const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$s);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$s, clientId, swarmName);
+    if (currentAgentName !== agentName) {
+        GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
+            swarm$1.loggerService.log('function "commitToolRequest" skipped due to the agent change', {
+                currentAgentName,
+                agentName,
+                clientId,
+            });
+        return null;
+    }
+    return await swarm$1.sessionPublicService.commitToolRequest(Array.isArray(request) ? request : [request], METHOD_NAME$s, clientId, swarmName);
+});
+
+const METHOD_NAME$r = "function.commit.commitToolRequestForce";
+/**
+ * Forcefully commits a tool request to the active agent in the swarm system.
+ * Validates the session and swarm, bypassing agent validation to directly commit the request.
+ * Runs within a beginContext wrapper for execution context management, logging operations via LoggerService.
+ * Integrates with SessionValidationService (session and swarm retrieval), SwarmValidationService (swarm validation),
+ * SessionPublicService (tool request committing), and LoggerService (logging).
+ * Complements functions like commitToolRequest by skipping agent validation for direct tool request commits.
+ *
+ * @param {IToolRequest | IToolRequest[]} request - The tool request(s) to commit, either as a single request or an array of requests.
+ * @param {string} clientId - The ID of the client associated with the session, validated against active sessions.
+ * @returns {Promise<string[]>} A promise that resolves with an array of results if the request is committed.
+ * @throws {Error} If session or swarm validation fails, propagated from respective validation services.
+ */
+const commitToolRequestForce = beginContext(async (request, clientId) => {
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
+        swarm$1.loggerService.log(METHOD_NAME$r, {
+            request,
+            clientId,
+        });
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$r);
+    const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$r);
+    return await swarm$1.sessionPublicService.commitToolRequest(Array.isArray(request) ? request : [request], METHOD_NAME$r, clientId, swarmName);
 });
 
 /** @constant {string} METHOD_NAME - The name of the method used for logging and validation */
@@ -23246,6 +23559,8 @@ exports.commitSystemMessage = commitSystemMessage;
 exports.commitSystemMessageForce = commitSystemMessageForce;
 exports.commitToolOutput = commitToolOutput;
 exports.commitToolOutputForce = commitToolOutputForce;
+exports.commitToolRequest = commitToolRequest;
+exports.commitToolRequestForce = commitToolRequestForce;
 exports.commitUserMessage = commitUserMessage;
 exports.commitUserMessageForce = commitUserMessageForce;
 exports.complete = complete;