agent-swarm-kit 1.1.4 → 1.1.6

package/build/index.cjs

@@ -4840,7 +4840,7 @@ class AgentConnectionService {
 }
 
 /** @private Constant defining the method name for logging purposes */
-const METHOD_NAME$19 = "function.common.getPayload";
+const METHOD_NAME$1b = "function.common.getPayload";
 /**
  * Retrieves the payload from the current PayloadContextService context.
  * Returns null if no context is available. Logs the operation if logging is enabled.
@@ -4851,7 +4851,7 @@ const METHOD_NAME$19 = "function.common.getPayload";
  * console.log(payload); // { id: number } or null
  */
 const getPayload = () => {
-    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$19);
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$1b);
     if (PayloadContextService.hasContext()) {
         const { payload } = swarm$1.payloadContextService.context;
         return payload;
@@ -14523,7 +14523,7 @@ const swarm = {
 init();
 var swarm$1 = swarm;
 
-const METHOD_NAME$18 = "cli.dumpDocs";
+const METHOD_NAME$1a = "cli.dumpDocs";
 /**
  * Dumps the documentation for the agents and swarms.
  *
@@ -14533,7 +14533,7 @@ const METHOD_NAME$18 = "cli.dumpDocs";
  */
 const dumpDocs = beginContext((prefix = "swarm", dirName = "./docs/chat", PlantUML) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$18, {
+        swarm$1.loggerService.log(METHOD_NAME$1a, {
             dirName,
         });
     if (PlantUML) {
@@ -14543,10 +14543,10 @@ const dumpDocs = beginContext((prefix = "swarm", dirName = "./docs/chat", PlantU
     }
     swarm$1.agentValidationService
         .getAgentList()
-        .forEach((agentName) => swarm$1.agentValidationService.validate(agentName, METHOD_NAME$18));
+        .forEach((agentName) => swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1a));
     swarm$1.swarmValidationService
         .getSwarmList()
-        .forEach((swarmName) => swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$18));
+        .forEach((swarmName) => swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1a));
     swarm$1.agentValidationService.getAgentList().forEach((agentName) => {
         const { dependsOn } = swarm$1.agentSchemaService.get(agentName);
         if (!dependsOn) {
@@ -14556,7 +14556,7 @@ const dumpDocs = beginContext((prefix = "swarm", dirName = "./docs/chat", PlantU
     return swarm$1.docService.dumpDocs(prefix, dirName);
 });
 
-const METHOD_NAME$17 = "cli.dumpAgent";
+const METHOD_NAME$19 = "cli.dumpAgent";
 /**
  * Dumps the agent information into PlantUML format.
  *
@@ -14565,14 +14565,14 @@ const METHOD_NAME$17 = "cli.dumpAgent";
  */
 const dumpAgent = beginContext((agentName, { withSubtree = false } = {}) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$17, {
+        swarm$1.loggerService.log(METHOD_NAME$19, {
             agentName,
         });
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$17);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$19);
     return swarm$1.agentMetaService.toUML(agentName, withSubtree);
 });
 
-const METHOD_NAME$16 = "cli.dumpSwarm";
+const METHOD_NAME$18 = "cli.dumpSwarm";
 /**
  * Dumps the swarm information into PlantUML format.
  *
@@ -14581,14 +14581,14 @@ const METHOD_NAME$16 = "cli.dumpSwarm";
  */
 const dumpSwarm = beginContext((swarmName) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$16, {
+        swarm$1.loggerService.log(METHOD_NAME$18, {
             swarmName,
         });
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$16);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$18);
     return swarm$1.swarmMetaService.toUML(swarmName);
 });
 
-const METHOD_NAME$15 = "cli.dumpPerfomance";
+const METHOD_NAME$17 = "cli.dumpPerfomance";
 const METHOD_NAME_INTERNAL$1 = "cli.dumpPerfomance.internal";
 const METHOD_NAME_INTERVAL = "cli.dumpPerfomance.interval";
 /**
@@ -14607,7 +14607,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$15);
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$17);
     await dumpPerfomanceInternal(dirName);
 };
 /**
@@ -14622,95 +14622,699 @@ dumpPerfomance.runInterval = beginContext((dirName = "./logs/meta", interval = 3
         swarm$1.loggerService.log(METHOD_NAME_INTERVAL);
     return functoolsKit.Source.fromInterval(interval).connect(() => dumpPerfomance(dirName));
 });
-
+
+/**
+ * Validates the client ID for execution event listening, allowing wildcard "*" or checking for an active session.
+ *
+ * @param {string} clientId - The client ID to validate.
+ * @throws {Error} If the client ID is not "*" and no active session exists for it.
+ */
+const validateClientId$h = (clientId) => {
+    if (clientId === "*") {
+        return;
+    }
+    if (!swarm$1.sessionValidationService.hasSession(clientId)) {
+        throw new Error(`agent-swarm listenExecutionEvent session not found for clientId=${clientId}`);
+    }
+};
+/**
+ * Subscribes to execution-specific events on the swarm bus service for a specific client and executes a callback for each event.
+ *
+ * This function sets up a listener for events on the "execution-bus" topic associated with a given client ID, invoking the provided callback with
+ * the event data whenever an execution event is received. It is wrapped in `beginContext` for a clean execution environment and logs the operation
+ * via `loggerService`. The callback is queued using `functools-kit` to ensure sequential processing of events. The function supports a wildcard
+ * client ID ("*") for listening to all clients or validates a specific client session. It returns an unsubscribe function to stop listening.
+ *
+ * @param {string} clientId - The ID of the client to subscribe to execution events for, or "*" to listen to all clients.
+ * @param {(event: IBusEvent) => void} fn - The callback function to execute when an execution event is received, passed the event object.
+ * @returns {() => void} A function to unsubscribe from the execution event listener.
+ * @throws {Error} If the `clientId` is not "*" and no active session exists for it.
+ * @example
+ * const unsubscribe = listenExecutionEvent("client-123", (event) => console.log(event));
+ * // Logs each execution event for "client-123"
+ * unsubscribe(); // Stops listening
+ */
+const listenExecutionEvent = beginContext((clientId, fn) => {
+    // Log the operation details
+    swarm$1.loggerService.log("middleware listenExecutionEvent", {
+        clientId,
+    });
+    // Validate the client ID
+    validateClientId$h(clientId);
+    // Subscribe to execution events with a queued callback
+    return swarm$1.busService.subscribe(clientId, "execution-bus", functoolsKit.queued(async (e) => await fn(e)));
+});
+
+const METHOD_NAME$16 = "cli.dumpClientPerformance";
+const METHOD_NAME_INTERNAL = "cli.dumpClientPerformance.internal";
+const METHOD_NAME_EXECUTE = "cli.dumpClientPerformance.execute";
+/**
+ * The internal HOF for handling the performance dump
+ *
+ * @param {string} clientId - The client ID for which the performance data is being dumped.
+ * @param {string} [dirName="./logs/client"] - The directory name where the performance data will be dumped.
+ * @returns {Promise<void>} A promise that resolves when the performance data has been dumped.
+ */
+const dumpClientPerformanceInternal = beginContext(async (clientId, dirName = "./logs/client") => {
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
+        swarm$1.loggerService.log(METHOD_NAME_INTERNAL);
+    return await swarm$1.docService.dumpClientPerfomance(clientId, dirName);
+});
+/**
+ * Dumps the performance data using the swarm's document service.
+ * Logs the method name if logging is enabled in the global configuration.
+ *
+ * @param {string} clientId - The client ID for which the performance data is being dumped.
+ * @param {string} [dirName="./logs/client"] - The directory name where the performance data will be dumped.
+ * @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$16);
+    await dumpClientPerformanceInternal(clientId, dirName);
+};
+/**
+ * Sets up a listener to dump performance data after execution.
+ * Logs the method name if logging is enabled in the global configuration.
+ *
+ * @param {string} [dirName="./logs/client"] - The directory name where the performance data will be dumped.
+ * @returns {Promise<void>} A promise that resolves when the listener has been set up.
+ */
+dumpClientPerformance.runAfterExecute = beginContext(async (dirName = "./logs/client") => {
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
+        swarm$1.loggerService.log(METHOD_NAME_EXECUTE);
+    return listenExecutionEvent("*", async ({ type, clientId }) => {
+        if (type === "commit-execution-end") {
+            await dumpClientPerformanceInternal(clientId, dirName);
+        }
+    });
+});
+
+/** @private Constant defining the method name for logging and validation context */
+const METHOD_NAME$15 = "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.
+ * Runs within a beginContext wrapper for execution context management, logging operations via LoggerService.
+ * Integrates with SessionValidationService (session and swarm retrieval), SwarmValidationService (swarm validation),
+ * SessionPublicService (history flush), and LoggerService (logging).
+ * Unlike commitFlush, this function skips agent validation and active agent checks, providing a more aggressive flush mechanism,
+ * analogous to commitAssistantMessageForce vs. commitAssistantMessage.
+ *
+ * @param {string} clientId - The ID of the client associated with the session, validated against active sessions.
+ * @param {string} agentName - The name of the agent (unused in this implementation, included for interface consistency with commitFlush).
+ * @returns {Promise<void>} A promise that resolves when the history flush is committed.
+ * @throws {Error} If session or swarm validation fails, propagated from respective validation services.
+ */
+const commitFlushForce = beginContext(async (clientId) => {
+    // Log the flush attempt if enabled
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
+        swarm$1.loggerService.log(METHOD_NAME$15, {
+            clientId,
+            METHOD_NAME: METHOD_NAME$15,
+        });
+    // Validate the session exists and retrieve the associated swarm
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$15);
+    const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
+    // Validate the swarm configuration
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$15);
+    // Commit the flush of agent history via SessionPublicService without agent checks
+    await swarm$1.sessionPublicService.commitFlush(METHOD_NAME$15, clientId, swarmName);
+});
+
+const METHOD_NAME$14 = "function.commit.commitToolOutputForce";
+/**
+ * Commits the output of a tool execution to the active agent in a swarm session without checking the active agent.
+ *
+ * This function forcefully commits the tool output to the session, bypassing the check for whether the agent is still active in the swarm session.
+ * It performs validation on the session and swarm, logs the operation if enabled, and delegates the commit operation to the session public service.
+ * The execution is wrapped in `beginContext` to ensure it runs outside of existing method and execution contexts, providing a clean execution environment.
+ *
+ * @param {string} toolId - The unique identifier of the tool whose output is being committed.
+ * @param {string} content - The content or result of the tool execution to be committed.
+ * @param {string} clientId - The unique identifier of the client session associated with the operation.
+ * @returns {Promise<void>} A promise that resolves when the tool output is successfully committed.
+ * @throws {Error} If validation fails (e.g., invalid session or swarm) or if the session public service encounters an error during the commit operation.
+ * @example
+ * await commitToolOutputForce("tool-123", "Tool execution result", "client-456");
+ */
+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$14, {
+            toolId,
+            content,
+            clientId,
+        });
+    // Validate the session and swarm to ensure they exist and are accessible
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$14);
+    const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$14);
+    // 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$14, 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$13 = "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.
+ * Logs the operation if enabled by global configuration.
+ * @param {string} clientId - The unique identifier of the client whose navigation route is being checked.
+ * @param {AgentName} agentName - The name of the agent to check within the navigation route.
+ * @returns {Promise<boolean>} A promise resolving to true if the agent is in the navigation route, false otherwise.
+ */
+const hasNavigation = async (clientId, agentName) => {
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
+        swarm$1.loggerService.log(METHOD_NAME$13, { clientId });
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$13);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$13);
+    const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
+    return swarm$1.navigationValidationService
+        .getNavigationRoute(clientId, swarmName)
+        .has(agentName);
+};
+
+const METHOD_NAME$12 = "function.history.getRawHistory";
+/**
+ * Retrieves the raw, unmodified history for a given client session.
+ *
+ * This function fetches the complete history associated with a client’s active agent in a swarm session, without any filtering or modifications.
+ * It is wrapped in `beginContext` for a clean execution environment and logs the operation if enabled via `GLOBAL_CONFIG`. The function validates
+ * the session and swarm, retrieves the current agent, and uses `historyPublicService.toArrayForRaw` to obtain the raw history as an array.
+ * The result is a fresh copy of the history array.
+ *
+ * @param {string} clientId - The unique identifier of the client session whose raw history is to be retrieved.
+ * @param {string} [methodName="function.history.getRawHistory"] - The name of the calling method, used for validation and logging (defaults to `METHOD_NAME`).
+ * @returns {Promise<object[]>} A promise that resolves to an array containing the raw history entries.
+ * @throws {Error} If session or swarm validation fails, or if history retrieval encounters an issue.
+ * @example
+ * const rawHistory = await getRawHistory("client-123");
+ * console.log(rawHistory); // Outputs the full raw history array
+ */
+const getRawHistory = beginContext(async (clientId, methodName = METHOD_NAME$12) => {
+    // Log the operation details if logging is enabled in GLOBAL_CONFIG
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
+        swarm$1.loggerService.log(METHOD_NAME$12, {
+            clientId,
+        });
+    // Validate the session and swarm
+    swarm$1.sessionValidationService.validate(clientId, methodName);
+    const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
+    swarm$1.swarmValidationService.validate(swarmName, methodName);
+    // Get the current agent and fetch raw history
+    const agentName = await swarm$1.swarmPublicService.getAgentName(methodName, clientId, swarmName);
+    const history = await swarm$1.historyPublicService.toArrayForRaw(methodName, clientId, agentName);
+    return [...history];
+});
+
+const METHOD_NAME$11 = "function.history.getLastUserMessage";
+/**
+ * Retrieves the content of the most recent user message from a client's session history.
+ *
+ * This function fetches the raw history for a specified client using `getRawHistory` and finds the last entry where the role is "user" and the mode
+ * is "user". It is wrapped in `beginContext` for a clean execution environment and logs the operation if enabled via `GLOBAL_CONFIG`. The result is
+ * the content of the last user message as a string, or `null` if no matching user message exists in the history.
+ *
+ * @param {string} clientId - The unique identifier of the client session whose last user message is to be retrieved.
+ * @returns {Promise<string | null>} A promise that resolves to the content of the last user message, or `null` if none is found.
+ * @throws {Error} If `getRawHistory` fails due to session validation or history retrieval issues.
+ * @example
+ * const lastMessage = await getLastUserMessage("client-123");
+ * console.log(lastMessage); // Outputs the last user message or null
+ */
+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$11, {
+            clientId,
+        });
+    // Fetch raw history and find the last user message
+    const history = await getRawHistory(clientId, METHOD_NAME$11);
+    const last = history.findLast(({ role, mode }) => role === "user" && mode === "user");
+    return last ? last.content : null;
+});
+
+const METHOD_NAME$10 = "function.navigate.changeToDefaultAgent";
+/**
+ * Time-to-live for the change agent function in milliseconds.
+ * Defines how long the cached change agent function remains valid before expiring.
+ * @constant {number}
+ */
+const CHANGE_AGENT_TTL$2 = 15 * 60 * 1000;
+/**
+ * Garbage collection interval for the change agent function in milliseconds.
+ * Specifies the frequency at which expired TTL entries are cleaned up.
+ * @constant {number}
+ */
+const CHANGE_AGENT_GC$2 = 60 * 1000;
+/**
+ * Creates a change agent function with time-to-live (TTL) and queuing capabilities for switching to the default agent.
+ *
+ * This factory function generates a queued, TTL-limited function to handle agent changes to the default agent for a specific client session,
+ * ensuring operations are executed sequentially and cached results are reused within the TTL period.
+ *
+ * @function
+ * @param {string} clientId - The unique identifier of the client session.
+ * @returns {TChangeToDefaultAgentRun} A function that performs the default agent change operation with queuing and TTL.
+ */
+const createChangeToDefaultAgent = functoolsKit.ttl((clientId) => functoolsKit.queued(async (methodName, agentName, swarmName) => {
+    if (!swarm$1.navigationValidationService.shouldNavigate(agentName, clientId, swarmName)) {
+        return false;
+    }
+    // Notify all agents in the swarm of the change
+    await Promise.all(swarm$1.swarmValidationService
+        .getAgentList(swarmName)
+        .map(async (agentName) => {
+        await swarm$1.agentPublicService.commitAgentChange(methodName, clientId, agentName);
+    }));
+    {
+        // Dispose of the current agent's resources and set up the new default agent
+        const agentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$10, clientId, swarmName);
+        await swarm$1.agentPublicService.dispose(methodName, clientId, agentName);
+        await swarm$1.historyPublicService.dispose(methodName, clientId, agentName);
+        await swarm$1.swarmPublicService.setAgentRef(methodName, clientId, swarmName, agentName, await swarm$1.agentPublicService.createAgentRef(methodName, clientId, agentName));
+    }
+    // Set the default agent as the active agent
+    await swarm$1.swarmPublicService.setAgentName(agentName, methodName, clientId, swarmName);
+    return true;
+}), {
+    key: ([clientId]) => `${clientId}`,
+    timeout: CHANGE_AGENT_TTL$2,
+});
+/**
+ * Creates a garbage collector for the change agent function.
+ *
+ * This function sets up a singleton interval-based garbage collector to periodically clean up expired TTL entries from `createChangeToDefaultAgent`.
+ *
+ * @function
+ * @returns {Promise<void>} A promise that resolves when the garbage collector is initialized.
+ */
+const createGc$3 = functoolsKit.singleshot(async () => {
+    setInterval(createChangeToDefaultAgent.gc, CHANGE_AGENT_GC$2);
+});
+/**
+ * Navigates back to the default agent for a given client session in a swarm.
+ *
+ * This function switches the active agent to the default agent defined in the swarm schema for the specified client session.
+ * It validates the session and default agent, logs the operation if enabled, and executes the change using a TTL-limited, queued runner.
+ * The execution is wrapped in `beginContext` to ensure it runs outside of existing method and execution contexts.
+ *
+ * @param {string} clientId - The unique identifier of the client session.
+ * @returns {Promise<boolean>} A promise that resolves when the default agent change is complete. If navigation stack contains recursion being canceled
+ * @throws {Error} If session or agent validation fails, or if the agent change process encounters an error.
+ * @example
+ * await changeToDefaultAgent("client-123");
+ */
+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$10, {
+            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$10);
+        swarm$1.agentValidationService.validate(agentName, METHOD_NAME$10);
+    }
+    // Execute the agent change with TTL and queuing
+    const run = await createChangeToDefaultAgent(clientId);
+    createGc$3();
+    return await run(METHOD_NAME$10, agentName, swarmName);
+});
+
+const METHOD_NAME$$ = "function.target.emitForce";
+/**
+ * Emits a string as model output without executing an incoming message or checking the active agent.
+ *
+ * This function directly emits a provided string as output from the swarm session, bypassing message execution and agent activity checks.
+ * It is designed exclusively for sessions established via `makeConnection`, ensuring compatibility with its connection model.
+ * The execution is wrapped in `beginContext` for a clean environment, validates the session and swarm, and throws an error if the session mode
+ * is not "makeConnection". The operation is logged if enabled, and resolves when the content is successfully emitted.
+ *
+ * @param {string} content - The content to be emitted as the model output.
+ * @param {string} clientId - The unique identifier of the client session emitting the content.
+ * @returns {Promise<void>} A promise that resolves when the content is emitted.
+ * @throws {Error} If the session mode is not "makeConnection", or if session or swarm validation fails.
+ * @example
+ * await emitForce("Direct output", "client-123"); // Emits "Direct output" in a makeConnection session
+ */
+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$$, {
+            content,
+            clientId,
+        });
+    // Validate the session and swarm
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$$);
+    const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$$);
+    // Emit the content directly via the session public service
+    return await swarm$1.sessionPublicService.emit(content, METHOD_NAME$$, clientId, swarmName);
+});
+
+const METHOD_NAME$_ = "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.
+ *
+ * This function executes a command or message on behalf of the active agent within a swarm session, designed for scenarios like reviewing tool output
+ * or initiating a model-to-client conversation. Unlike `execute`, it does not check if the agent is currently active, ensuring execution even if the
+ * agent has changed or is inactive. It validates the session and swarm, executes the content with performance tracking and event bus notifications,
+ * and is wrapped in `beginContext` for a clean environment and `ExecutionContextService` for metadata tracking.
+ *
+ * @param {string} content - The content or command to be executed by the active agent.
+ * @param {string} clientId - The unique identifier of the client session requesting the execution.
+ * @returns {Promise<string>} A promise that resolves to the result of the execution.
+ * @throws {Error} If session or swarm validation fails, or if the execution process encounters an error.
+ * @example
+ * const result = await executeForce("Force this execution", "client-123");
+ * console.log(result); // Outputs the agent's response regardless of its active state
+ */
+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$_, {
+            content,
+            clientId,
+            executionId,
+        });
+    // Validate the session and swarm
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$_);
+    const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$_);
+    // 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$_, clientId, swarmName);
+            isFinished = swarm$1.perfService.endExecution(executionId, clientId, result.length);
+            swarm$1.busService.commitExecutionEnd(clientId, { swarmName });
+            return result;
+        }
+        finally {
+            if (!isFinished) {
+                swarm$1.perfService.endExecution(executionId, clientId, 0);
+            }
+        }
+    }, {
+        clientId,
+        executionId,
+        processId: GLOBAL_CONFIG.CC_PROCESS_UUID,
+    });
+});
+
+const METHOD_NAME$Z = "function.template.navigateToTriageAgent";
+const DEFAULT_ACCEPT_FN = (_, defaultAgent) => `Successfully navigated to ${defaultAgent}`;
+const DEFAULT_REJECT_FN = (_, defaultAgent) => `Already on ${defaultAgent}`;
+/**
+ * Creates a function to navigate to a triage agent for a specific client, handling navigation, message execution, and tool output.
+ * The factory generates a handler that checks navigation state, commits tool outputs with accept/reject messages, and triggers execution or emission based on provided parameters.
+ * It operates outside any existing method or execution contexts to ensure isolation, leveraging `beginContext` for a clean execution scope.
+ * Logs the navigation operation if logging is enabled in the global configuration.
+ *
+ * @param {IFactoryParams} params - Configuration parameters for the navigation handler.
+ * @param {string | ((clientId: string, defaultAgent: AgentName) => string | Promise<string>)} [params.flushMessage] - Optional message or function to emit after flushing the session.
+ * @param {string | ((clientId: string, defaultAgent: AgentName) => string | Promise<string>)} [params.executeMessage] - Optional message or function to execute if no navigation is needed.
+ * @param {string | ((clientId: string, defaultAgent: AgentName) => string | Promise<string>)} [params.toolOutputAccept] - Optional message or function for tool output when navigation occurs, defaults to `DEFAULT_ACCEPT_FN`.
+ * @param {string | ((clientId: string, defaultAgent: AgentName) => string | Promise<string>)} [params.toolOutputReject] - Optional message or function for tool output when already on the default agent, defaults to `DEFAULT_REJECT_FN`.
+ * @returns {Promise<(toolId: string, clientId: string) => Promise<void>>} A promise resolving to a function that handles navigation to the triage agent.
+ * @throws {Error} If neither `flushMessage` nor `executeMessage` is provided, or if any internal operation (e.g., navigation, commit, or execution) fails.
+ *
+ * @example
+ * // Create a navigation handler with a static flush message
+ * const navigate = await createNavigateToTriageAgent({
+ *   flushMessage: "Session reset for triage.",
+ *   toolOutputAccept: "Navigation completed.",
+ * });
+ * await navigate("tool-123", "client-456");
+ * // Navigates to default agent, commits custom tool output, and emits the flush message if applicable.
+ *
+ * @example
+ * // Create a navigation handler with dynamic messages
+ * const navigate = await createNavigateToTriageAgent({
+ *   executeMessage: (clientId, agent) => `Processing ${clientId} on ${agent}`,
+ *   toolOutputReject: (clientId, agent) => `No navigation needed for ${clientId}`,
+ * });
+ * await navigate("tool-789", "client-012");
+ * // Commits dynamic reject message and executes the message if already on the default agent.
+ */
+const createNavigateToTriageAgent = async ({ flushMessage, executeMessage, toolOutputAccept = DEFAULT_ACCEPT_FN, toolOutputReject = DEFAULT_REJECT_FN, }) => {
+    if (!flushMessage && !executeMessage) {
+        throw new Error("agent-swarm createNavigateToTriageAgent flushMessage or executeMessage required");
+    }
+    /**
+     * Navigates to the default triage agent for a given client and tool, handling message commits and execution.
+     *
+     * @param {string} toolId - The identifier of the tool triggering the navigation.
+     * @param {string} clientId - The unique identifier of the client session.
+     * @returns {Promise<void>} A promise that resolves when the navigation and associated actions are complete.
+     * @throws {Error} If navigation, commit, or execution operations fail (e.g., invalid clientId or swarm configuration).
+     */
+    return beginContext(async (toolId, clientId) => {
+        GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
+            swarm$1.loggerService.log(METHOD_NAME$Z, {
+                clientId,
+                toolId,
+            });
+        const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
+        const { defaultAgent } = swarm$1.swarmSchemaService.get(swarmName);
+        if (await functoolsKit.not(hasNavigation(clientId, defaultAgent))) {
+            const lastMessage = await getLastUserMessage(clientId);
+            await changeToDefaultAgent(clientId);
+            await commitToolOutputForce(toolId, typeof toolOutputAccept === "string"
+                ? toolOutputAccept
+                : await toolOutputAccept(clientId, defaultAgent), clientId);
+            await executeForce(lastMessage, clientId);
+        }
+        if (flushMessage) {
+            await commitFlushForce(clientId);
+            await emitForce(typeof flushMessage === "string"
+                ? flushMessage
+                : await flushMessage(clientId, defaultAgent), clientId);
+            return;
+        }
+        await commitToolOutputForce(toolId, typeof toolOutputReject === "string"
+            ? toolOutputReject
+            : await toolOutputReject(clientId, defaultAgent), clientId);
+        await executeForce(typeof executeMessage === "string"
+            ? executeMessage
+            : await executeMessage(clientId, defaultAgent), clientId);
+    });
+};
+
+const METHOD_NAME$Y = "function.navigate.changeToAgent";
+/**
+ * Time-to-live for the change agent function in milliseconds.
+ * Defines how long the cached change agent function remains valid before expiring.
+ * @constant {number}
+ */
+const CHANGE_AGENT_TTL$1 = 15 * 60 * 1000;
+/**
+ * Garbage collection interval for the change agent function in milliseconds.
+ * Specifies the frequency at which expired TTL entries are cleaned up.
+ * @constant {number}
+ */
+const CHANGE_AGENT_GC$1 = 60 * 1000;
+/**
+ * Creates a change agent function with time-to-live (TTL) and queuing capabilities.
+ *
+ * This factory function generates a queued, TTL-limited function to handle agent changes for a specific client session,
+ * ensuring operations are executed sequentially and cached results are reused within the TTL period.
+ *
+ * @function
+ * @param {string} clientId - The unique identifier of the client session.
+ * @returns {TChangeToAgentRun} A function that performs the agent change operation with queuing and TTL.
+ */
+const createChangeToAgent = functoolsKit.ttl((clientId) => functoolsKit.queued(async (methodName, agentName, swarmName) => {
+    if (!swarm$1.navigationValidationService.shouldNavigate(agentName, clientId, swarmName)) {
+        console.warn(`function "changeToAgent" skipped due to the circular route found clientId=${clientId} swarmName=${swarmName} agentNameTo=${agentName}`);
+        return false;
+    }
+    // Notify all agents in the swarm of the change
+    await Promise.all(swarm$1.swarmValidationService
+        .getAgentList(swarmName)
+        .map(async (agentName) => {
+        await swarm$1.agentPublicService.commitAgentChange(methodName, clientId, agentName);
+    }));
+    {
+        // Dispose of the current agent's resources and set up the new agent
+        const agentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$Y, clientId, swarmName);
+        await swarm$1.agentPublicService.dispose(methodName, clientId, agentName);
+        await swarm$1.historyPublicService.dispose(methodName, clientId, agentName);
+        await swarm$1.swarmPublicService.setAgentRef(methodName, clientId, swarmName, agentName, await swarm$1.agentPublicService.createAgentRef(methodName, clientId, agentName));
+    }
+    // Set the new agent as the active agent
+    await swarm$1.swarmPublicService.setAgentName(agentName, methodName, clientId, swarmName);
+    return true;
+}), {
+    key: ([clientId]) => `${clientId}`,
+    timeout: CHANGE_AGENT_TTL$1,
+});
 /**
- * Validates the client ID for execution event listening, allowing wildcard "*" or checking for an active session.
+ * Creates a garbage collector for the change agent function.
  *
- * @param {string} clientId - The client ID to validate.
- * @throws {Error} If the client ID is not "*" and no active session exists for it.
+ * This function sets up a singleton interval-based garbage collector to periodically clean up expired TTL entries from `createChangeToAgent`.
+ *
+ * @function
+ * @returns {Promise<void>} A promise that resolves when the garbage collector is initialized.
  */
-const validateClientId$h = (clientId) => {
-    if (clientId === "*") {
-        return;
-    }
-    if (!swarm$1.sessionValidationService.hasSession(clientId)) {
-        throw new Error(`agent-swarm listenExecutionEvent session not found for clientId=${clientId}`);
-    }
-};
+const createGc$2 = functoolsKit.singleshot(async () => {
+    setInterval(createChangeToAgent.gc, CHANGE_AGENT_GC$1);
+});
 /**
- * Subscribes to execution-specific events on the swarm bus service for a specific client and executes a callback for each event.
+ * Changes the active agent for a given client session in a swarm.
  *
- * This function sets up a listener for events on the "execution-bus" topic associated with a given client ID, invoking the provided callback with
- * the event data whenever an execution event is received. It is wrapped in `beginContext` for a clean execution environment and logs the operation
- * via `loggerService`. The callback is queued using `functools-kit` to ensure sequential processing of events. The function supports a wildcard
- * client ID ("*") for listening to all clients or validates a specific client session. It returns an unsubscribe function to stop listening.
+ * This function facilitates switching the active agent in a swarm session, validating the session and agent dependencies,
+ * logging the operation if enabled, and executing the change using a TTL-limited, queued runner.
+ * The execution is wrapped in `beginContext` to ensure it runs outside of existing method and execution contexts.
  *
- * @param {string} clientId - The ID of the client to subscribe to execution events for, or "*" to listen to all clients.
- * @param {(event: IBusEvent) => void} fn - The callback function to execute when an execution event is received, passed the event object.
- * @returns {() => void} A function to unsubscribe from the execution event listener.
- * @throws {Error} If the `clientId` is not "*" and no active session exists for it.
+ * @param {AgentName} agentName - The name of the agent to switch to.
+ * @param {string} clientId - The unique identifier of the client session.
+ * @returns {Promise<boolean>} A promise that resolves when the agent change is complete. If it resolved false, the navigation is canceled due to recursion
+ * @throws {Error} If session or agent validation fails, or if the agent change process encounters an error.
  * @example
- * const unsubscribe = listenExecutionEvent("client-123", (event) => console.log(event));
- * // Logs each execution event for "client-123"
- * unsubscribe(); // Stops listening
+ * await changeToAgent("AgentX", "client-123");
  */
-const listenExecutionEvent = beginContext((clientId, fn) => {
-    // Log the operation details
-    swarm$1.loggerService.log("middleware listenExecutionEvent", {
-        clientId,
-    });
-    // Validate the client ID
-    validateClientId$h(clientId);
-    // Subscribe to execution events with a queued callback
-    return swarm$1.busService.subscribe(clientId, "execution-bus", functoolsKit.queued(async (e) => await fn(e)));
+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$Y, {
+            agentName,
+            clientId,
+        });
+    const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
+    {
+        // Validate session, agent, and dependencies
+        swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$Y);
+        swarm$1.agentValidationService.validate(agentName, METHOD_NAME$Y);
+        const activeAgent = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$Y, clientId, swarmName);
+        if (!swarm$1.agentValidationService.hasDependency(activeAgent, agentName)) {
+            console.error(`agent-swarm missing dependency detected for activeAgent=${activeAgent} dependencyAgent=${agentName}`);
+        }
+    }
+    if (!swarm$1.swarmValidationService.getAgentSet(swarmName).has(agentName)) {
+        GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
+            swarm$1.loggerService.log('function "changeToAgent" skipped due to the agent is not in the swarm', {
+                agentName,
+                clientId,
+                swarmName,
+            });
+        console.warn(`function "changeToAgent" skipped due to the agent is not in the swarm clientId=${clientId} agentName=${agentName} swarmName=${swarmName}`);
+        return false;
+    }
+    // Execute the agent change with TTL and queuing
+    const run = await createChangeToAgent(clientId);
+    createGc$2();
+    return await run(METHOD_NAME$Y, agentName, swarmName);
 });
 
-const METHOD_NAME$14 = "cli.dumpClientPerformance";
-const METHOD_NAME_INTERNAL = "cli.dumpClientPerformance.internal";
-const METHOD_NAME_EXECUTE = "cli.dumpClientPerformance.execute";
+const METHOD_NAME$X = "function.template.navigateToAgent";
 /**
- * The internal HOF for handling the performance dump
+ * Default tool output message indicating successful navigation to the specified agent.
  *
- * @param {string} clientId - The client ID for which the performance data is being dumped.
- * @param {string} [dirName="./logs/client"] - The directory name where the performance data will be dumped.
- * @returns {Promise<void>} A promise that resolves when the performance data has been dumped.
+ * @param {SessionId} _ - The client session ID (unused).
+ * @param {AgentName} agentName - The name of the agent navigated to.
+ * @returns {string} A message confirming navigation to the agent.
  */
-const dumpClientPerformanceInternal = beginContext(async (clientId, dirName = "./logs/client") => {
-    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME_INTERNAL);
-    return await swarm$1.docService.dumpClientPerfomance(clientId, dirName);
-});
+const DEFAULT_TOOL_OUTPUT = (_, agentName) => `Successfully navigated to ${agentName}`;
 /**
- * Dumps the performance data using the swarm's document service.
- * Logs the method name if logging is enabled in the global configuration.
+ * Default flush message prompting the user to repeat their input.
  *
- * @param {string} clientId - The client ID for which the performance data is being dumped.
- * @param {string} [dirName="./logs/client"] - The directory name where the performance data will be dumped.
- * @returns {Promise<void>} A promise that resolves when the performance data has been dumped.
+ * @param {SessionId} _ - The client session ID (unused).
+ * @param {AgentName} _ - The agent name (unused).
+ * @returns {string} A generic retry message.
  */
-const dumpClientPerformance = async (clientId, dirName = "./logs/client") => {
-    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$14);
-    await dumpClientPerformanceInternal(clientId, dirName);
-};
+const DEFAULT_FLUSH_MESSAGE = ({}, {}) => `Sorry, I missed that. Could you repeat please`;
 /**
- * Sets up a listener to dump performance data after execution.
- * Logs the method name if logging is enabled in the global configuration.
+ * Creates a function to navigate to a specified agent for a given client, handling navigation, message execution, emission, and tool output.
+ * The factory generates a handler that checks navigation state, retrieves the last user message, commits tool outputs, and triggers execution or emission based on provided parameters.
+ * It validates the presence of either `emitMessage` or `executeMessage` to ensure proper navigation behavior.
+ * Logs the navigation operation if logging is enabled in the global configuration.
  *
- * @param {string} [dirName="./logs/client"] - The directory name where the performance data will be dumped.
- * @returns {Promise<void>} A promise that resolves when the listener has been set up.
+ * @param {IFactoryParams} params - Configuration parameters for the navigation handler.
+ * @param {string | ((clientId: string, defaultAgent: AgentName) => string | Promise<string>)} [params.flushMessage] - Optional message or function to emit after flushing the session, defaults to `DEFAULT_FLUSH_MESSAGE`.
+ * @param {string | ((clientId: string, agentName: AgentName) => string | Promise<string>)} [params.toolOutput] - Optional message or function for tool output when navigation occurs, defaults to `DEFAULT_TOOL_OUTPUT`.
+ * @param {string | ((clientId: string, lastMessage: string, agentName: AgentName) => string | Promise<string>)} [params.emitMessage] - Optional message or function to emit when navigation occurs without execution.
+ * @param {string | ((clientId: string, lastMessage: string, agentName: AgentName) => string | Promise<string>)} [params.executeMessage] - Optional message or function to execute when navigation occurs with execution.
+ * @returns {Promise<(toolId: string, clientId: string, agentName: AgentName) => Promise<void>>} A promise resolving to a function that handles navigation to the specified agent.
+ * @throws {Error} If neither `emitMessage` nor `executeMessage` is provided, or if any internal operation (e.g., navigation, commit, or execution) fails.
+ *
+ * @example
+ * // Create a navigation handler with static messages
+ * const navigate = await createNavigateToAgent({
+ *   flushMessage: "Session reset.",
+ *   toolOutput: "Navigation completed.",
+ *   emitMessage: "Navigation event triggered.",
+ * });
+ * await navigate("tool-123", "client-456", "WeatherAgent");
+ * // Navigates to WeatherAgent, commits tool output, and emits the message.
+ *
+ * @example
+ * // Create a navigation handler with dynamic messages
+ * const navigate = await createNavigateToAgent({
+ *   executeMessage: (clientId, lastMessage, agent) => `Processing ${lastMessage} for ${clientId} on ${agent}`,
+ *   toolOutput: (clientId, agent) => `Navigated ${clientId} to ${agent}`,
+ * });
+ * await navigate("tool-789", "client-012", "SupportAgent");
+ * // Navigates to SupportAgent, commits dynamic tool output, and executes the message with the last user message.
  */
-dumpClientPerformance.runAfterExecute = beginContext(async (dirName = "./logs/client") => {
-    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME_EXECUTE);
-    return listenExecutionEvent("*", async ({ type, clientId }) => {
-        if (type === "commit-execution-end") {
-            await dumpClientPerformanceInternal(clientId, dirName);
+const createNavigateToAgent = async ({ executeMessage, emitMessage, flushMessage = DEFAULT_FLUSH_MESSAGE, toolOutput = DEFAULT_TOOL_OUTPUT, }) => {
+    if (!emitMessage && !executeMessage) {
+        throw new Error("agent-swarm createNavigateToAgent emitMessage or executeMessage required");
+    }
+    /**
+     * Navigates to a specified agent for a given client and tool, handling message commits, execution, or emission using the last user message.
+     *
+     * @param {string} toolId - The identifier of the tool triggering the navigation.
+     * @param {string} clientId - The unique identifier of the client session.
+     * @param {AgentName} agentName - The name of the agent to navigate to.
+     * @returns {Promise<void>} A promise that resolves when the navigation and associated actions are complete.
+     * @throws {Error} If navigation, commit, execution, or emission operations fail (e.g., invalid clientId or agentName).
+     */
+    return beginContext(async (toolId, clientId, agentName) => {
+        GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
+            swarm$1.loggerService.log(METHOD_NAME$X, {
+                clientId,
+                toolId,
+            });
+        const lastMessage = await getLastUserMessage(clientId);
+        if (await functoolsKit.and(functoolsKit.not(hasNavigation(clientId, agentName)), Promise.resolve(!!executeMessage))) {
+            await commitToolOutputForce(toolId, typeof toolOutput === "string"
+                ? toolOutput
+                : await toolOutput(clientId, agentName), clientId);
+            await changeToAgent(agentName, clientId);
+            await executeForce(typeof executeMessage === "string"
+                ? executeMessage
+                : await executeMessage(clientId, lastMessage, agentName), clientId);
+            return;
+        }
+        if (await functoolsKit.and(functoolsKit.not(hasNavigation(clientId, agentName)), Promise.resolve(!!emitMessage))) {
+            await commitToolOutputForce(toolId, typeof toolOutput === "string"
+                ? toolOutput
+                : await toolOutput(clientId, agentName), clientId);
+            await changeToAgent(agentName, clientId);
+            await emitForce(typeof emitMessage === "string"
+                ? emitMessage
+                : await emitMessage(clientId, lastMessage, agentName), clientId);
+            return;
         }
+        await commitFlushForce(clientId);
+        await emitForce(typeof flushMessage === "string"
+            ? flushMessage
+            : await flushMessage(clientId, agentName), clientId);
     });
-});
+};
 
 /** @constant {string} METHOD_NAME - The name of the method used for logging */
-const METHOD_NAME$13 = "function.setup.addWiki";
+const METHOD_NAME$W = "function.setup.addWiki";
 /**
  * Adds a wiki schema to the system
  * @function addWiki
@@ -14719,7 +15323,7 @@ const METHOD_NAME$13 = "function.setup.addWiki";
  */
 const addWiki = beginContext((wikiSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$13, {
+        swarm$1.loggerService.log(METHOD_NAME$W, {
             wikiSchema,
         });
     swarm$1.wikiValidationService.addWiki(wikiSchema.wikiName, wikiSchema);
@@ -14727,7 +15331,7 @@ const addWiki = beginContext((wikiSchema) => {
     return wikiSchema.wikiName;
 });
 
-const METHOD_NAME$12 = "function.setup.addAgent";
+const METHOD_NAME$V = "function.setup.addAgent";
 /**
  * Adds a new agent to the agent registry for use within the swarm system.
  *
@@ -14747,7 +15351,7 @@ const METHOD_NAME$12 = "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$12, {
+        swarm$1.loggerService.log(METHOD_NAME$V, {
             agentSchema,
         });
     // Register the agent in the validation and schema services
@@ -14757,7 +15361,7 @@ const addAgent = beginContext((agentSchema) => {
     return agentSchema.agentName;
 });
 
-const METHOD_NAME$11 = "function.setup.addCompletion";
+const METHOD_NAME$U = "function.setup.addCompletion";
 /**
  * Adds a completion engine to the registry for use by agents in the swarm system.
  *
@@ -14777,7 +15381,7 @@ const METHOD_NAME$11 = "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$11, {
+        swarm$1.loggerService.log(METHOD_NAME$U, {
             completionSchema,
         });
     // Register the completion in the validation and schema services
@@ -14787,7 +15391,7 @@ const addCompletion = beginContext((completionSchema) => {
     return completionSchema.completionName;
 });
 
-const METHOD_NAME$10 = "function.setup.addSwarm";
+const METHOD_NAME$T = "function.setup.addSwarm";
 /**
  * Adds a new swarm to the system for managing client sessions.
  *
@@ -14807,7 +15411,7 @@ const METHOD_NAME$10 = "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$10, {
+        swarm$1.loggerService.log(METHOD_NAME$T, {
             swarmSchema,
         });
     // Register the swarm in the validation and schema services
@@ -14817,7 +15421,7 @@ const addSwarm = beginContext((swarmSchema) => {
     return swarmSchema.swarmName;
 });
 
-const METHOD_NAME$$ = "function.setup.addTool";
+const METHOD_NAME$S = "function.setup.addTool";
 /**
  * Adds a new tool to the tool registry for use by agents in the swarm system.
  *
@@ -14839,7 +15443,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$S, {
             toolSchema,
         });
     // Register the tool in the validation and schema services
@@ -14849,7 +15453,7 @@ const addTool = beginContext((toolSchema) => {
     return toolSchema.toolName;
 });
 
-const METHOD_NAME$_ = "function.setup.addState";
+const METHOD_NAME$R = "function.setup.addState";
 /**
  * Adds a new state to the state registry for use within the swarm system.
  *
@@ -14871,7 +15475,7 @@ const METHOD_NAME$_ = "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$_, {
+        swarm$1.loggerService.log(METHOD_NAME$R, {
             stateSchema,
         });
     // Register the state in the schema service
@@ -14886,7 +15490,7 @@ const addState = beginContext((stateSchema) => {
     return stateSchema.stateName;
 });
 
-const METHOD_NAME$Z = "function.setup.addEmbedding";
+const METHOD_NAME$Q = "function.setup.addEmbedding";
 /**
  * Adds a new embedding engine to the embedding registry for use within the swarm system.
  *
@@ -14906,7 +15510,7 @@ const METHOD_NAME$Z = "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$Z, {
+        swarm$1.loggerService.log(METHOD_NAME$Q, {
             embeddingSchema,
         });
     // Register the embedding in the validation and schema services
@@ -14916,7 +15520,7 @@ const addEmbedding = beginContext((embeddingSchema) => {
     return embeddingSchema.embeddingName;
 });
 
-const METHOD_NAME$Y = "function.setup.addStorage";
+const METHOD_NAME$P = "function.setup.addStorage";
 /**
  * Adds a new storage engine to the storage registry for use within the swarm system.
  *
@@ -14938,7 +15542,7 @@ const METHOD_NAME$Y = "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$Y, {
+        swarm$1.loggerService.log(METHOD_NAME$P, {
             storageSchema,
         });
     // Register the storage in the validation and schema services
@@ -14955,7 +15559,7 @@ const addStorage = beginContext((storageSchema) => {
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$X = "function.setup.addPolicy";
+const METHOD_NAME$O = "function.setup.addPolicy";
 /**
  * Adds a new policy for agents in the swarm system by registering it with validation and schema services.
  * Registers the policy with PolicyValidationService for runtime validation and PolicySchemaService for schema management.
@@ -14971,7 +15575,7 @@ const METHOD_NAME$X = "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$X, {
+        swarm$1.loggerService.log(METHOD_NAME$O, {
             policySchema,
         });
     // Register the policy with PolicyValidationService for runtime validation
@@ -14982,7 +15586,7 @@ const addPolicy = beginContext((policySchema) => {
     return policySchema.policyName;
 });
 
-const METHOD_NAME$W = "function.test.overrideAgent";
+const METHOD_NAME$N = "function.test.overrideAgent";
 /**
  * Overrides an existing agent schema in the swarm system with a new or partial schema.
  * This function updates the configuration of an agent identified by its `agentName`, applying the provided schema properties.
@@ -15006,13 +15610,13 @@ const METHOD_NAME$W = "function.test.overrideAgent";
  */
 const overrideAgent = beginContext((agentSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$W, {
+        swarm$1.loggerService.log(METHOD_NAME$N, {
             agentSchema,
         });
     return swarm$1.agentSchemaService.override(agentSchema.agentName, agentSchema);
 });
 
-const METHOD_NAME$V = "function.test.overrideCompletion";
+const METHOD_NAME$M = "function.test.overrideCompletion";
 /**
  * Overrides an existing completion schema in the swarm system with a new or partial schema.
  * This function updates the configuration of a completion mechanism identified by its `completionName`, applying the provided schema properties.
@@ -15036,13 +15640,13 @@ const METHOD_NAME$V = "function.test.overrideCompletion";
  */
 const overrideCompletion = beginContext((completionSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$V, {
+        swarm$1.loggerService.log(METHOD_NAME$M, {
             completionSchema,
         });
     return swarm$1.completionSchemaService.override(completionSchema.completionName, completionSchema);
 });
 
-const METHOD_NAME$U = "function.test.overrideEmbeding";
+const METHOD_NAME$L = "function.test.overrideEmbeding";
 /**
  * Overrides an existing embedding schema in the swarm system with a new or partial schema.
  * This function updates the configuration of an embedding mechanism identified by its `embeddingName`, applying the provided schema properties.
@@ -15068,13 +15672,13 @@ const METHOD_NAME$U = "function.test.overrideEmbeding";
  */
 const overrideEmbeding = beginContext((embeddingSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$U, {
+        swarm$1.loggerService.log(METHOD_NAME$L, {
             embeddingSchema,
         });
     return swarm$1.embeddingSchemaService.override(embeddingSchema.embeddingName, embeddingSchema);
 });
 
-const METHOD_NAME$T = "function.test.overridePolicy";
+const METHOD_NAME$K = "function.test.overridePolicy";
 /**
  * Overrides an existing policy schema in the swarm system with a new or partial schema.
  * This function updates the configuration of a policy identified by its `policyName`, applying the provided schema properties.
@@ -15098,13 +15702,13 @@ const METHOD_NAME$T = "function.test.overridePolicy";
  */
 const overridePolicy = beginContext((policySchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$T, {
+        swarm$1.loggerService.log(METHOD_NAME$K, {
             policySchema,
         });
     return swarm$1.policySchemaService.override(policySchema.policyName, policySchema);
 });
 
-const METHOD_NAME$S = "function.test.overrideState";
+const METHOD_NAME$J = "function.test.overrideState";
 /**
  * Overrides an existing state schema in the swarm system with a new or partial schema.
  * This function updates the configuration of a state identified by its `stateName`, applying the provided schema properties.
@@ -15129,13 +15733,13 @@ const METHOD_NAME$S = "function.test.overrideState";
  */
 const overrideState = beginContext((stateSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$S, {
+        swarm$1.loggerService.log(METHOD_NAME$J, {
             stateSchema,
         });
     return swarm$1.stateSchemaService.override(stateSchema.stateName, stateSchema);
 });
 
-const METHOD_NAME$R = "function.test.overrideStorage";
+const METHOD_NAME$I = "function.test.overrideStorage";
 /**
  * Overrides an existing storage schema in the swarm system with a new or partial schema.
  * This function updates the configuration of a storage identified by its `storageName`, applying the provided schema properties.
@@ -15161,13 +15765,13 @@ const METHOD_NAME$R = "function.test.overrideStorage";
  */
 const overrideStorage = beginContext((storageSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$R, {
+        swarm$1.loggerService.log(METHOD_NAME$I, {
             storageSchema,
         });
     return swarm$1.storageSchemaService.override(storageSchema.storageName, storageSchema);
 });
 
-const METHOD_NAME$Q = "function.test.overrideSwarm";
+const METHOD_NAME$H = "function.test.overrideSwarm";
 /**
  * Overrides an existing swarm schema in the swarm system with a new or partial schema.
  * This function updates the configuration of a swarm identified by its `swarmName`, applying the provided schema properties.
@@ -15191,13 +15795,13 @@ const METHOD_NAME$Q = "function.test.overrideSwarm";
  */
 const overrideSwarm = beginContext((swarmSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$Q, {
+        swarm$1.loggerService.log(METHOD_NAME$H, {
             swarmSchema,
         });
     return swarm$1.swarmSchemaService.override(swarmSchema.swarmName, swarmSchema);
 });
 
-const METHOD_NAME$P = "function.test.overrideTool";
+const METHOD_NAME$G = "function.test.overrideTool";
 /**
  * Overrides an existing tool schema in the swarm system with a new or partial schema.
  * This function updates the configuration of a tool identified by its `toolName`, applying the provided schema properties.
@@ -15221,13 +15825,13 @@ const METHOD_NAME$P = "function.test.overrideTool";
  */
 const overrideTool = beginContext((toolSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$P, {
+        swarm$1.loggerService.log(METHOD_NAME$G, {
             toolSchema,
         });
     return swarm$1.toolSchemaService.override(toolSchema.toolName, toolSchema);
 });
 
-const METHOD_NAME$O = "function.test.overrideWiki";
+const METHOD_NAME$F = "function.test.overrideWiki";
 /**
  * Overrides an existing wiki schema in the swarm system with a new or partial schema.
  * This function updates the configuration of a wiki identified by its `wikiName`, applying the provided schema properties.
@@ -15251,13 +15855,13 @@ const METHOD_NAME$O = "function.test.overrideWiki";
  */
 const overrideWiki = beginContext((wikiSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$O, {
+        swarm$1.loggerService.log(METHOD_NAME$F, {
             wikiSchema,
         });
     return swarm$1.wikiSchemaService.override(wikiSchema.wikiName, wikiSchema);
 });
 
-const METHOD_NAME$N = "function.other.markOnline";
+const METHOD_NAME$E = "function.other.markOnline";
 /**
  * Marks a client as online in the specified swarm.
  *
@@ -15269,16 +15873,16 @@ const METHOD_NAME$N = "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$N, {
+        swarm.loggerService.log(METHOD_NAME$E, {
             clientId,
         });
     // Validate the swarm name
-    swarm.swarmValidationService.validate(swarmName, METHOD_NAME$N);
+    swarm.swarmValidationService.validate(swarmName, METHOD_NAME$E);
     // Run the operation in the method context
     return await MethodContextService.runInContext(async () => {
-        await swarm.aliveService.markOnline(clientId, swarmName, METHOD_NAME$N);
+        await swarm.aliveService.markOnline(clientId, swarmName, METHOD_NAME$E);
     }, {
-        methodName: METHOD_NAME$N,
+        methodName: METHOD_NAME$E,
         agentName: "",
         policyName: "",
         stateName: "",
@@ -15288,7 +15892,7 @@ const markOnline = async (clientId, swarmName) => {
     });
 };
 
-const METHOD_NAME$M = "function.other.markOffline";
+const METHOD_NAME$D = "function.other.markOffline";
 /**
  * Marks a client as offline in the specified swarm.
  *
@@ -15303,14 +15907,14 @@ const METHOD_NAME$M = "function.other.markOffline";
  */
 const markOffline = async (clientId, swarmName) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm.loggerService.log(METHOD_NAME$M, {
+        swarm.loggerService.log(METHOD_NAME$D, {
             clientId,
         });
-    swarm.swarmValidationService.validate(swarmName, METHOD_NAME$M);
+    swarm.swarmValidationService.validate(swarmName, METHOD_NAME$D);
     return await MethodContextService.runInContext(async () => {
-        await swarm.aliveService.markOffline(clientId, swarmName, METHOD_NAME$M);
+        await swarm.aliveService.markOffline(clientId, swarmName, METHOD_NAME$D);
     }, {
-        methodName: METHOD_NAME$M,
+        methodName: METHOD_NAME$D,
         agentName: "",
         policyName: "",
         stateName: "",
@@ -15320,7 +15924,7 @@ const markOffline = async (clientId, swarmName) => {
     });
 };
 
-const METHOD_NAME$L = "function.commit.commitToolOutput";
+const METHOD_NAME$C = "function.commit.commitToolOutput";
 /**
  * Commits the output of a tool execution to the active agent in a swarm session.
  *
@@ -15340,19 +15944,19 @@ const METHOD_NAME$L = "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$L, {
+        swarm$1.loggerService.log(METHOD_NAME$C, {
             toolId,
             content,
             clientId,
             agentName,
         });
     // Validate the agent, session, and swarm to ensure they exist and are accessible
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$L);
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$L);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$C);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$C);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$L);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$C);
     // Check if the specified agent is still the active agent in the swarm session
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$L, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$C, clientId, swarmName);
     if (currentAgentName !== agentName) {
         // Log a skip message if the agent has changed during the operation
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
@@ -15365,11 +15969,11 @@ const commitToolOutput = beginContext(async (toolId, content, clientId, agentNam
         return;
     }
     // Commit the tool output to the session via the session public service
-    await swarm$1.sessionPublicService.commitToolOutput(toolId, content, METHOD_NAME$L, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitToolOutput(toolId, content, METHOD_NAME$C, clientId, swarmName);
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$K = "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.
@@ -15388,20 +15992,20 @@ const METHOD_NAME$K = "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$K, {
+        swarm$1.loggerService.log(METHOD_NAME$B, {
             content,
             clientId,
             agentName,
         });
     // Validate the agent exists
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$K);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$B);
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$K);
+    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$K);
+    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$K, 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', {
@@ -15412,11 +16016,11 @@ const commitSystemMessage = beginContext(async (content, clientId, agentName) =>
         return;
     }
     // Commit the system message via SessionPublicService
-    await swarm$1.sessionPublicService.commitSystemMessage(content, METHOD_NAME$K, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitSystemMessage(content, METHOD_NAME$B, clientId, swarmName);
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$J = "function.commit.commitFlush";
+const METHOD_NAME$A = "function.commit.commitFlush";
 /**
  * Commits a flush of agent history for a specific client and agent in the swarm system.
  * Validates the agent, session, and swarm, ensuring the current agent matches the provided agent before flushing the history.
@@ -15433,19 +16037,19 @@ const METHOD_NAME$J = "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$J, {
+        swarm$1.loggerService.log(METHOD_NAME$A, {
             clientId,
             agentName,
         });
     // Validate the agent exists
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$J);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$A);
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$J);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$A);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$J);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$A);
     // Check if the current agent matches the provided agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$J, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$A, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "commitFlush" skipped due to the agent change', {
@@ -15456,10 +16060,10 @@ const commitFlush = beginContext(async (clientId, agentName) => {
         return;
     }
     // Commit the flush of agent history via SessionPublicService
-    await swarm$1.sessionPublicService.commitFlush(METHOD_NAME$J, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitFlush(METHOD_NAME$A, clientId, swarmName);
 });
 
-const METHOD_NAME$I = "function.commit.commitSystemMessage";
+const METHOD_NAME$z = "function.commit.commitSystemMessage";
 /**
  * Commits a user message to the active agent's history in a swarm session without triggering a response.
  *
@@ -15478,19 +16082,19 @@ const METHOD_NAME$I = "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$I, {
+        swarm$1.loggerService.log(METHOD_NAME$z, {
             content,
             clientId,
             agentName,
             mode,
         });
     // Validate the agent, session, and swarm to ensure they exist and are accessible
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$I);
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$I);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$z);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$z);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$I);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$z);
     // Check if the specified agent is still the active agent in the swarm session
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$I, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$z, clientId, swarmName);
     if (currentAgentName !== agentName) {
         // Log a skip message if the agent has changed during the operation
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
@@ -15503,50 +16107,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$I, clientId, swarmName);
+            await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$z, clientId, swarmName);
         }, {
             clientId,
             payload,
         });
     }
     // Commit the user message to the agent's history via the session public service
-    return await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$I, clientId, swarmName);
-});
-
-const METHOD_NAME$H = "function.commit.commitToolOutputForce";
-/**
- * Commits the output of a tool execution to the active agent in a swarm session without checking the active agent.
- *
- * This function forcefully commits the tool output to the session, bypassing the check for whether the agent is still active in the swarm session.
- * It performs validation on the session and swarm, logs the operation if enabled, and delegates the commit operation to the session public service.
- * The execution is wrapped in `beginContext` to ensure it runs outside of existing method and execution contexts, providing a clean execution environment.
- *
- * @param {string} toolId - The unique identifier of the tool whose output is being committed.
- * @param {string} content - The content or result of the tool execution to be committed.
- * @param {string} clientId - The unique identifier of the client session associated with the operation.
- * @returns {Promise<void>} A promise that resolves when the tool output is successfully committed.
- * @throws {Error} If validation fails (e.g., invalid session or swarm) or if the session public service encounters an error during the commit operation.
- * @example
- * await commitToolOutputForce("tool-123", "Tool execution result", "client-456");
- */
-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$H, {
-            toolId,
-            content,
-            clientId,
-        });
-    // Validate the session and swarm to ensure they exist and are accessible
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$H);
-    const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$H);
-    // Commit the tool output to the session via the session public service without checking the active agent
-    await swarm$1.sessionPublicService.commitToolOutput(toolId, content, METHOD_NAME$H, clientId, swarmName);
+    return await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$z, clientId, swarmName);
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$G = "function.commit.commitSystemMessageForce";
+const METHOD_NAME$y = "function.commit.commitSystemMessageForce";
 /**
  * Forcefully commits a system-generated message to a session in the swarm system, without checking the active agent.
  * Validates the session and swarm, then proceeds with committing the message regardless of the current agent state.
@@ -15565,52 +16137,20 @@ const METHOD_NAME$G = "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$G, {
+        swarm$1.loggerService.log(METHOD_NAME$y, {
             content,
             clientId,
         });
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$G);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$y);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$G);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$y);
     // Commit the system message via SessionPublicService without agent checks
-    await swarm$1.sessionPublicService.commitSystemMessage(content, METHOD_NAME$G, clientId, swarmName);
-});
-
-/** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$F = "function.commit.commitFlushForce";
-/**
- * Forcefully commits a flush of agent history for a specific client in the swarm system, without checking the active agent.
- * Validates the session and swarm, then proceeds with flushing the history regardless of the current agent state.
- * Runs within a beginContext wrapper for execution context management, logging operations via LoggerService.
- * Integrates with SessionValidationService (session and swarm retrieval), SwarmValidationService (swarm validation),
- * SessionPublicService (history flush), and LoggerService (logging).
- * Unlike commitFlush, this function skips agent validation and active agent checks, providing a more aggressive flush mechanism,
- * analogous to commitAssistantMessageForce vs. commitAssistantMessage.
- *
- * @param {string} clientId - The ID of the client associated with the session, validated against active sessions.
- * @param {string} agentName - The name of the agent (unused in this implementation, included for interface consistency with commitFlush).
- * @returns {Promise<void>} A promise that resolves when the history flush is committed.
- * @throws {Error} If session or swarm validation fails, propagated from respective validation services.
- */
-const commitFlushForce = beginContext(async (clientId) => {
-    // Log the flush attempt if enabled
-    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$F, {
-            clientId,
-            METHOD_NAME: METHOD_NAME$F,
-        });
-    // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$F);
-    const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$F);
-    // Commit the flush of agent history via SessionPublicService without agent checks
-    await swarm$1.sessionPublicService.commitFlush(METHOD_NAME$F, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitSystemMessage(content, METHOD_NAME$y, clientId, swarmName);
 });
 
-const METHOD_NAME$E = "function.commit.commitSystemMessage";
+const METHOD_NAME$x = "function.commit.commitSystemMessage";
 /**
  * Commits a user message to the active agent's history in a swarm session without triggering a response and without checking the active agent.
  *
@@ -15628,29 +16168,29 @@ const METHOD_NAME$E = "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$E, {
+        swarm$1.loggerService.log(METHOD_NAME$x, {
             content,
             clientId,
             mode,
         });
     // Validate the session and swarm to ensure they exist and are accessible
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$E);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$x);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$E);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$x);
     if (payload) {
         return await PayloadContextService.runInContext(async () => {
-            await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$E, clientId, swarmName);
+            await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$x, clientId, swarmName);
         }, {
             clientId,
             payload,
         });
     }
     // Commit the user message to the agent's history via the session public service without checking the active agent
-    return await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$E, clientId, swarmName);
+    return await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$x, clientId, swarmName);
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$D = "function.commit.commitAssistantMessage";
+const METHOD_NAME$w = "function.commit.commitAssistantMessage";
 /**
  * Commits an assistant-generated message to the active agent in the swarm system.
  * Validates the agent, session, and swarm, ensuring the current agent matches the provided agent before committing the message.
@@ -15668,20 +16208,20 @@ const METHOD_NAME$D = "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$D, {
+        swarm$1.loggerService.log(METHOD_NAME$w, {
             content,
             clientId,
             agentName,
         });
     // Validate the agent exists
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$D);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$w);
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$D);
+    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$D);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$w);
     // Check if the current agent matches the provided agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$D, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$w, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "commitAssistantMessage" skipped due to the agent change', {
@@ -15692,11 +16232,11 @@ const commitAssistantMessage = beginContext(async (content, clientId, agentName)
         return;
     }
     // Commit the assistant message via SessionPublicService
-    await swarm$1.sessionPublicService.commitAssistantMessage(content, METHOD_NAME$D, 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$C = "function.commit.commitAssistantMessageForce";
+const METHOD_NAME$v = "function.commit.commitAssistantMessageForce";
 /**
  * Forcefully commits an assistant-generated message to a session in the swarm system, without checking the active agent.
  * Validates the session and swarm, then proceeds with committing the message regardless of the current agent state.
@@ -15715,21 +16255,21 @@ const METHOD_NAME$C = "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$C, {
+        swarm$1.loggerService.log(METHOD_NAME$v, {
             content,
             clientId,
         });
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$C);
+    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$C);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$v);
     // Commit the assistant message via SessionPublicService without agent checks
-    await swarm$1.sessionPublicService.commitAssistantMessage(content, METHOD_NAME$C, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitAssistantMessage(content, METHOD_NAME$v, clientId, swarmName);
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$B = "function.commit.cancelOutput";
+const METHOD_NAME$u = "function.commit.cancelOutput";
 /**
  * Cancels the awaited output for a specific client and agent by emitting an empty string.
  * Validates the agent, session, and swarm, ensuring the current agent matches the provided agent before cancellation.
@@ -15745,19 +16285,19 @@ const METHOD_NAME$B = "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$B, {
+        swarm$1.loggerService.log(METHOD_NAME$u, {
             clientId,
             agentName,
         });
     // Validate the agent exists
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$B);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$u);
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$B);
+    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$B);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$u);
     // Check if the current agent matches the provided agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$B, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$u, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "cancelOutput" skipped due to the agent change', {
@@ -15768,11 +16308,11 @@ const cancelOutput = beginContext(async (clientId, agentName) => {
         return;
     }
     // Perform the output cancellation via SwarmPublicService
-    await swarm$1.swarmPublicService.cancelOutput(METHOD_NAME$B, 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$A = "function.commit.cancelOutputForce";
+const METHOD_NAME$t = "function.commit.cancelOutputForce";
 /**
  * Forcefully cancels the awaited output for a specific client by emitting an empty string, without checking the active agent.
  * Validates the session and swarm, then proceeds with cancellation regardless of the current agent state.
@@ -15789,20 +16329,20 @@ const METHOD_NAME$A = "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$A, {
+        swarm$1.loggerService.log(METHOD_NAME$t, {
             clientId,
         });
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$A);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$t);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$A);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$t);
     // Perform the output cancellation via SwarmPublicService without agent checks
-    await swarm$1.swarmPublicService.cancelOutput(METHOD_NAME$A, clientId, swarmName);
+    await swarm$1.swarmPublicService.cancelOutput(METHOD_NAME$t, clientId, swarmName);
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$z = "function.commit.commitStopTools";
+const METHOD_NAME$s = "function.commit.commitStopTools";
 /**
  * Prevents the next tool from being executed for a specific client and agent in the swarm system.
  * Validates the agent, session, and swarm, ensuring the current agent matches the provided agent before stopping tool execution.
@@ -15819,19 +16359,19 @@ const METHOD_NAME$z = "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$z, {
+        swarm$1.loggerService.log(METHOD_NAME$s, {
             clientId,
             agentName,
         });
     // Validate the agent exists
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$z);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$s);
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$z);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$s);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$z);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$s);
     // Check if the current agent matches the provided agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$z, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$s, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "commitStopTools" skipped due to the agent change', {
@@ -15842,11 +16382,11 @@ const commitStopTools = beginContext(async (clientId, agentName) => {
         return;
     }
     // Commit the stop of the next tool execution via SessionPublicService
-    await swarm$1.sessionPublicService.commitStopTools(METHOD_NAME$z, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitStopTools(METHOD_NAME$s, clientId, swarmName);
 });
 
 /** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$y = "function.commit.commitStopToolsForce";
+const METHOD_NAME$r = "function.commit.commitStopToolsForce";
 /**
  * Forcefully prevents the next tool from being executed for a specific client in the swarm system, without checking the active agent.
  * Validates the session and swarm, then proceeds with stopping tool execution regardless of the current agent state.
@@ -15864,105 +16404,21 @@ const METHOD_NAME$y = "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$y, {
+        swarm$1.loggerService.log(METHOD_NAME$r, {
             clientId,
-            METHOD_NAME: METHOD_NAME$y,
+            METHOD_NAME: METHOD_NAME$r,
         });
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$y);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$r);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$y);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$r);
     // Commit the stop of the next tool execution via SessionPublicService without agent checks
-    await swarm$1.sessionPublicService.commitStopTools(METHOD_NAME$y, clientId, swarmName);
-});
-
-const METHOD_NAME$x = "function.target.emitForce";
-/**
- * Emits a string as model output without executing an incoming message or checking the active agent.
- *
- * This function directly emits a provided string as output from the swarm session, bypassing message execution and agent activity checks.
- * It is designed exclusively for sessions established via `makeConnection`, ensuring compatibility with its connection model.
- * The execution is wrapped in `beginContext` for a clean environment, validates the session and swarm, and throws an error if the session mode
- * is not "makeConnection". The operation is logged if enabled, and resolves when the content is successfully emitted.
- *
- * @param {string} content - The content to be emitted as the model output.
- * @param {string} clientId - The unique identifier of the client session emitting the content.
- * @returns {Promise<void>} A promise that resolves when the content is emitted.
- * @throws {Error} If the session mode is not "makeConnection", or if session or swarm validation fails.
- * @example
- * await emitForce("Direct output", "client-123"); // Emits "Direct output" in a makeConnection session
- */
-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$x, {
-            content,
-            clientId,
-        });
-    // Validate the session and swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$x);
-    const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$x);
-    // Emit the content directly via the session public service
-    return await swarm$1.sessionPublicService.emit(content, METHOD_NAME$x, clientId, swarmName);
-});
-
-const METHOD_NAME$w = "function.target.executeForce";
-/**
- * Sends a message to the active agent in a swarm session as if it originated from the client side, forcing execution regardless of agent activity.
- *
- * This function executes a command or message on behalf of the active agent within a swarm session, designed for scenarios like reviewing tool output
- * or initiating a model-to-client conversation. Unlike `execute`, it does not check if the agent is currently active, ensuring execution even if the
- * agent has changed or is inactive. It validates the session and swarm, executes the content with performance tracking and event bus notifications,
- * and is wrapped in `beginContext` for a clean environment and `ExecutionContextService` for metadata tracking.
- *
- * @param {string} content - The content or command to be executed by the active agent.
- * @param {string} clientId - The unique identifier of the client session requesting the execution.
- * @returns {Promise<string>} A promise that resolves to the result of the execution.
- * @throws {Error} If session or swarm validation fails, or if the execution process encounters an error.
- * @example
- * const result = await executeForce("Force this execution", "client-123");
- * console.log(result); // Outputs the agent's response regardless of its active state
- */
-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$w, {
-            content,
-            clientId,
-            executionId,
-        });
-    // Validate the session and swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$w);
-    const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$w);
-    // Execute the command within an execution context with performance tracking
-    return ExecutionContextService.runInContext(async () => {
-        let isFinished = false;
-        swarm$1.perfService.startExecution(executionId, clientId, content.length);
-        try {
-            swarm$1.busService.commitExecutionBegin(clientId, { swarmName });
-            const result = await swarm$1.sessionPublicService.execute(content, "tool", METHOD_NAME$w, clientId, swarmName);
-            isFinished = swarm$1.perfService.endExecution(executionId, clientId, result.length);
-            swarm$1.busService.commitExecutionEnd(clientId, { swarmName });
-            return result;
-        }
-        finally {
-            if (!isFinished) {
-                swarm$1.perfService.endExecution(executionId, clientId, 0);
-            }
-        }
-    }, {
-        clientId,
-        executionId,
-        processId: GLOBAL_CONFIG.CC_PROCESS_UUID,
-    });
+    await swarm$1.sessionPublicService.commitStopTools(METHOD_NAME$r, clientId, swarmName);
 });
 
 /** @constant {string} METHOD_NAME - The name of the method used for logging and validation */
-const METHOD_NAME$v = "function.target.question";
+const METHOD_NAME$q = "function.target.question";
 /**
  * Initiates a question process within a chat context
  * @function question
@@ -15974,21 +16430,21 @@ const METHOD_NAME$v = "function.target.question";
  */
 const question = beginContext(async (message, clientId, agentName, wikiName) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$v, {
+        swarm$1.loggerService.log(METHOD_NAME$q, {
             message,
             clientId,
             agentName,
             wikiName,
         });
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$v);
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$v);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$q);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$q);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$v);
-    swarm$1.wikiValidationService.validate(wikiName, METHOD_NAME$v);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$q);
+    swarm$1.wikiValidationService.validate(wikiName, METHOD_NAME$q);
     if (!swarm$1.agentValidationService.hasWiki(agentName, wikiName)) {
-        throw new Error(`agent-swarm ${METHOD_NAME$v} ${wikiName} not registered in ${agentName}`);
+        throw new Error(`agent-swarm ${METHOD_NAME$q} ${wikiName} not registered in ${agentName}`);
     }
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$v, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$q, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "question" skipped due to the agent change', {
@@ -16011,7 +16467,7 @@ const question = beginContext(async (message, clientId, agentName, wikiName) =>
 });
 
 /** @constant {string} METHOD_NAME - The name of the method used for logging and validation */
-const METHOD_NAME$u = "function.target.questionForce";
+const METHOD_NAME$p = "function.target.questionForce";
 /**
  * Initiates a forced question process within a chat context
  * @function questionForce
@@ -16022,17 +16478,17 @@ const METHOD_NAME$u = "function.target.questionForce";
  */
 const questionForce = beginContext(async (message, clientId, wikiName) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$u, {
+        swarm$1.loggerService.log(METHOD_NAME$p, {
             message,
             clientId,
             wikiName,
         });
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$u);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$p);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$u);
-    swarm$1.wikiValidationService.validate(wikiName, METHOD_NAME$u);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$p);
+    swarm$1.wikiValidationService.validate(wikiName, METHOD_NAME$p);
     const { getChat, callbacks } = swarm$1.wikiSchemaService.get(wikiName);
-    const agentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$u, clientId, swarmName);
+    const agentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$p, clientId, swarmName);
     const args = {
         clientId,
         message,
@@ -16044,7 +16500,7 @@ const questionForce = beginContext(async (message, clientId, wikiName) => {
     return await getChat(args);
 });
 
-const METHOD_NAME$t = "function.target.disposeConnection";
+const METHOD_NAME$o = "function.target.disposeConnection";
 /**
  * Disposes of a client session and all related resources within a swarm.
  *
@@ -16061,10 +16517,10 @@ const METHOD_NAME$t = "function.target.disposeConnection";
  * @example
  * await disposeConnection("client-123", "TaskSwarm");
  */
-const disposeConnection = beginContext(async (clientId, swarmName, methodName = METHOD_NAME$t) => {
+const disposeConnection = beginContext(async (clientId, swarmName, methodName = METHOD_NAME$o) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$t, {
+        swarm$1.loggerService.log(METHOD_NAME$o, {
             clientId,
             swarmName,
         });
@@ -16136,7 +16592,7 @@ const disposeConnection = beginContext(async (clientId, swarmName, methodName =
     PersistMemoryAdapter.dispose(clientId);
 });
 
-const METHOD_NAME$s = "function.target.makeAutoDispose";
+const METHOD_NAME$n = "function.target.makeAutoDispose";
 /**
  * Default timeout in seconds before auto-dispose is triggered.
  * @constant {number}
@@ -16167,7 +16623,7 @@ const DEFAULT_TIMEOUT = 15 * 60;
 const makeAutoDispose = beginContext((clientId, swarmName, { timeoutSeconds = DEFAULT_TIMEOUT, onDestroy, } = {}) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$s, {
+        swarm$1.loggerService.log(METHOD_NAME$n, {
             clientId,
             swarmName,
         });
@@ -16200,7 +16656,7 @@ const makeAutoDispose = beginContext((clientId, swarmName, { timeoutSeconds = DE
     };
 });
 
-const METHOD_NAME$r = "function.target.execute";
+const METHOD_NAME$m = "function.target.execute";
 /**
  * Sends a message to the active agent in a swarm session as if it originated from the client side.
  *
@@ -16222,19 +16678,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$r, {
+        swarm$1.loggerService.log(METHOD_NAME$m, {
             content,
             clientId,
             agentName,
             executionId,
         });
     // Validate the agent, session, and swarm
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$r);
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$r);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$m);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$m);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$r);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$m);
     // Check if the specified agent is still the active agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$r, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$m, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "execute" skipped due to the agent change', {
@@ -16253,7 +16709,7 @@ const execute = beginContext(async (content, clientId, agentName) => {
                 agentName,
                 swarmName,
             });
-            const result = await swarm$1.sessionPublicService.execute(content, "tool", METHOD_NAME$r, clientId, swarmName);
+            const result = await swarm$1.sessionPublicService.execute(content, "tool", METHOD_NAME$m, clientId, swarmName);
             isFinished = swarm$1.perfService.endExecution(executionId, clientId, result.length);
             swarm$1.busService.commitExecutionEnd(clientId, {
                 agentName,
@@ -16273,7 +16729,7 @@ const execute = beginContext(async (content, clientId, agentName) => {
     });
 });
 
-const METHOD_NAME$q = "function.target.emit";
+const METHOD_NAME$l = "function.target.emit";
 /**
  * Emits a string as model output without executing an incoming message, with agent activity validation.
  *
@@ -16293,18 +16749,18 @@ const METHOD_NAME$q = "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$q, {
+        swarm$1.loggerService.log(METHOD_NAME$l, {
             content,
             clientId,
             agentName,
         });
     // Validate the agent, session, and swarm
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$q);
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$q);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$l);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$l);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$q);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$l);
     // Check if the specified agent is still the active agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$q, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$l, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "emit" skipped due to the agent change', {
@@ -16315,10 +16771,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$q, clientId, swarmName);
+    return await swarm$1.sessionPublicService.emit(content, METHOD_NAME$l, clientId, swarmName);
 });
 
-const METHOD_NAME$p = "function.target.notify";
+const METHOD_NAME$k = "function.target.notify";
 /**
  * Sends a notification message as output from the swarm session without executing an incoming message.
  *
@@ -16338,23 +16794,23 @@ const METHOD_NAME$p = "function.target.notify";
 const notify = beginContext(async (content, clientId, agentName) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$p, {
+        swarm$1.loggerService.log(METHOD_NAME$k, {
             content,
             clientId,
             agentName,
         });
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$p);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$k);
     // Check if the session mode is "makeConnection"
     if (swarm$1.sessionValidationService.getSessionMode(clientId) !==
         "makeConnection") {
         throw new Error(`agent-swarm-kit notify session is not makeConnection clientId=${clientId}`);
     }
     // Validate the agent, session, and swarm
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$p);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$k);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$p);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$k);
     // Check if the specified agent is still the active agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$p, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$k, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "notify" skipped due to the agent change', {
@@ -16365,10 +16821,10 @@ const notify = beginContext(async (content, clientId, agentName) => {
         return;
     }
     // Notify the content directly via the session public service
-    return await swarm$1.sessionPublicService.notify(content, METHOD_NAME$p, clientId, swarmName);
+    return await swarm$1.sessionPublicService.notify(content, METHOD_NAME$k, clientId, swarmName);
 });
 
-const METHOD_NAME$o = "function.target.notifyForce";
+const METHOD_NAME$j = "function.target.notifyForce";
 /**
  * Sends a notification message as output from the swarm session without executing an incoming message.
  *
@@ -16387,11 +16843,11 @@ const METHOD_NAME$o = "function.target.notifyForce";
 const notifyForce = beginContext(async (content, clientId) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$o, {
+        swarm$1.loggerService.log(METHOD_NAME$j, {
             content,
             clientId,
         });
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$o);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$j);
     // Check if the session mode is "makeConnection"
     if (swarm$1.sessionValidationService.getSessionMode(clientId) !==
         "makeConnection") {
@@ -16399,12 +16855,12 @@ const notifyForce = beginContext(async (content, clientId) => {
     }
     // Validate the agent, session, and swarm
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$o);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$j);
     // Notify the content directly via the session public service
-    return await swarm$1.sessionPublicService.notify(content, METHOD_NAME$o, clientId, swarmName);
+    return await swarm$1.sessionPublicService.notify(content, METHOD_NAME$j, clientId, swarmName);
 });
 
-const METHOD_NAME$n = "function.target.runStateless";
+const METHOD_NAME$i = "function.target.runStateless";
 /**
  * Executes a message statelessly with an agent in a swarm session, bypassing chat history.
  *
@@ -16427,19 +16883,19 @@ const runStateless = beginContext(async (content, clientId, agentName) => {
     const executionId = functoolsKit.randomString();
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$n, {
+        swarm$1.loggerService.log(METHOD_NAME$i, {
             content,
             clientId,
             agentName,
             executionId,
         });
     // Validate the agent, session, and swarm
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$n);
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$n);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$i);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$i);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$n);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$i);
     // Check if the specified agent is still the active agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$n, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$i, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "runStateless" skipped due to the agent change', {
@@ -16458,7 +16914,7 @@ const runStateless = beginContext(async (content, clientId, agentName) => {
                 agentName,
                 swarmName,
             });
-            const result = await swarm$1.sessionPublicService.run(content, METHOD_NAME$n, clientId, swarmName);
+            const result = await swarm$1.sessionPublicService.run(content, METHOD_NAME$i, clientId, swarmName);
             isFinished = swarm$1.perfService.endExecution(executionId, clientId, result.length);
             swarm$1.busService.commitExecutionEnd(clientId, {
                 agentName,
@@ -16478,7 +16934,7 @@ const runStateless = beginContext(async (content, clientId, agentName) => {
     });
 });
 
-const METHOD_NAME$m = "function.target.runStatelessForce";
+const METHOD_NAME$h = "function.target.runStatelessForce";
 /**
  * Executes a message statelessly with the active agent in a swarm session, bypassing chat history and forcing execution regardless of agent activity.
  *
@@ -16499,22 +16955,22 @@ const runStatelessForce = beginContext(async (content, clientId) => {
     const executionId = functoolsKit.randomString();
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$m, {
+        swarm$1.loggerService.log(METHOD_NAME$h, {
             content,
             clientId,
             executionId,
         });
     // Validate the session and swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$m);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$h);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$m);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$h);
     // Execute the command statelessly within an execution context with performance tracking
     return ExecutionContextService.runInContext(async () => {
         let isFinished = false;
         swarm$1.perfService.startExecution(executionId, clientId, content.length);
         try {
             swarm$1.busService.commitExecutionBegin(clientId, { swarmName });
-            const result = await swarm$1.sessionPublicService.run(content, METHOD_NAME$m, clientId, swarmName);
+            const result = await swarm$1.sessionPublicService.run(content, METHOD_NAME$h, clientId, swarmName);
             isFinished = swarm$1.perfService.endExecution(executionId, clientId, result.length);
             swarm$1.busService.commitExecutionEnd(clientId, { swarmName });
             return result;
@@ -16541,7 +16997,7 @@ const SCHEDULED_DELAY$1 = 1000;
  * @constant {number}
  */
 const RATE_DELAY = 10000;
-const METHOD_NAME$l = "function.target.makeConnection";
+const METHOD_NAME$g = "function.target.makeConnection";
 /**
  * Internal implementation of the connection factory for a client to a swarm.
  *
@@ -16556,21 +17012,21 @@ const METHOD_NAME$l = "function.target.makeConnection";
 const makeConnectionInternal = (connector, clientId, swarmName) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$l, {
+        swarm$1.loggerService.log(METHOD_NAME$g, {
             clientId,
             swarmName,
         });
     // Validate the swarm and initialize the session
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$l);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$g);
     swarm$1.sessionValidationService.addSession(clientId, swarmName, "makeConnection");
     // Create a queued send function using the session public service
-    const send = functoolsKit.queued(swarm$1.sessionPublicService.connect(connector, METHOD_NAME$l, clientId, swarmName));
+    const send = functoolsKit.queued(swarm$1.sessionPublicService.connect(connector, METHOD_NAME$g, clientId, swarmName));
     // Return a wrapped send function with validation and agent context
     return (async (outgoing) => {
-        swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$l);
+        swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$g);
         return await send({
             data: outgoing,
-            agentName: await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$l, clientId, swarmName),
+            agentName: await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$g, clientId, swarmName),
             clientId,
         });
     });
@@ -16653,13 +17109,13 @@ makeConnection.scheduled = (connector, clientId, swarmName, { delay = SCHEDULED_
             await online();
             if (payload) {
                 return await PayloadContextService.runInContext(async () => {
-                    await swarm$1.sessionPublicService.commitUserMessage(content, "user", METHOD_NAME$l, clientId, swarmName);
+                    await swarm$1.sessionPublicService.commitUserMessage(content, "user", METHOD_NAME$g, clientId, swarmName);
                 }, {
                     clientId,
                     payload,
                 });
             }
-            await swarm$1.sessionPublicService.commitUserMessage(content, "user", METHOD_NAME$l, clientId, swarmName);
+            await swarm$1.sessionPublicService.commitUserMessage(content, "user", METHOD_NAME$g, clientId, swarmName);
         }),
         delay,
     });
@@ -16722,7 +17178,7 @@ makeConnection.rate = (connector, clientId, swarmName, { delay = RATE_DELAY } =
     };
 };
 
-const METHOD_NAME$k = "function.target.complete";
+const METHOD_NAME$f = "function.target.complete";
 /**
  * Time-to-live for the complete function in milliseconds.
  * Defines how long the cached complete function remains valid before expiring.
@@ -16764,7 +17220,7 @@ const createComplete = functoolsKit.ttl((clientId, swarmName) => functoolsKit.qu
  *
  * @returns {Promise<void>} A promise that resolves when the garbage collector is initialized.
  */
-const createGc$3 = functoolsKit.singleshot(async () => {
+const createGc$1 = functoolsKit.singleshot(async () => {
     setInterval(createComplete.gc, COMPLETE_GC);
 });
 /**
@@ -16788,7 +17244,7 @@ const complete = beginContext(async (content, clientId, swarmName, payload = nul
     const executionId = functoolsKit.randomString();
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$k, {
+        swarm$1.loggerService.log(METHOD_NAME$f, {
             content,
             clientId,
             executionId,
@@ -16797,7 +17253,7 @@ const complete = beginContext(async (content, clientId, swarmName, payload = nul
     await markOnline(clientId, swarmName);
     // Set up the TTL-limited, queued execution function and garbage collector
     const run = await createComplete(clientId, swarmName);
-    createGc$3();
+    createGc$1();
     // Execute the command within an execution context with performance tracking
     const handleRun = async () => {
         return await ExecutionContextService.runInContext(async () => {
@@ -16806,7 +17262,7 @@ const complete = beginContext(async (content, clientId, swarmName, payload = nul
             swarm$1.navigationValidationService.beginMonit(clientId, swarmName);
             try {
                 swarm$1.busService.commitExecutionBegin(clientId, { swarmName });
-                const result = await run(METHOD_NAME$k, content);
+                const result = await run(METHOD_NAME$f, content);
                 isFinished = swarm$1.perfService.endExecution(executionId, clientId, result.length);
                 swarm$1.busService.commitExecutionEnd(clientId, { swarmName });
                 return result;
@@ -16836,7 +17292,7 @@ const complete = beginContext(async (content, clientId, swarmName, payload = nul
  * @constant {number}
  */
 const SCHEDULED_DELAY = 1000;
-const METHOD_NAME$j = "function.target.session";
+const METHOD_NAME$e = "function.target.session";
 /**
  * Internal implementation of the session factory for a client and swarm.
  *
@@ -16851,23 +17307,23 @@ const sessionInternal = (clientId, swarmName, { onDispose = () => { } } = {}) =>
     const executionId = functoolsKit.randomString();
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$j, {
+        swarm$1.loggerService.log(METHOD_NAME$e, {
             clientId,
             swarmName,
             executionId,
         });
     // Validate the swarm and initialize the session
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$j);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$e);
     swarm$1.sessionValidationService.addSession(clientId, swarmName, "session");
     const complete = functoolsKit.queued(async (content) => {
-        swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$j);
+        swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$e);
         return ExecutionContextService.runInContext(async () => {
             let isFinished = false;
             swarm$1.perfService.startExecution(executionId, clientId, content.length);
             swarm$1.navigationValidationService.beginMonit(clientId, swarmName);
             try {
                 swarm$1.busService.commitExecutionBegin(clientId, { swarmName });
-                const result = await swarm$1.sessionPublicService.execute(content, "user", METHOD_NAME$j, clientId, swarmName);
+                const result = await swarm$1.sessionPublicService.execute(content, "user", METHOD_NAME$e, clientId, swarmName);
                 isFinished = swarm$1.perfService.endExecution(executionId, clientId, result.length);
                 swarm$1.busService.commitExecutionEnd(clientId, { swarmName });
                 return result;
@@ -16888,7 +17344,7 @@ const sessionInternal = (clientId, swarmName, { onDispose = () => { } } = {}) =>
             return await complete(content);
         }),
         dispose: async () => {
-            await disposeConnection(clientId, swarmName, METHOD_NAME$j);
+            await disposeConnection(clientId, swarmName, METHOD_NAME$e);
             await onDispose();
         },
     };
@@ -16988,13 +17444,13 @@ session.scheduled = (clientId, swarmName, { delay = SCHEDULED_DELAY, onDispose }
             await online();
             if (payload) {
                 return await PayloadContextService.runInContext(async () => {
-                    return await swarm$1.sessionPublicService.commitUserMessage(content, "user", METHOD_NAME$j, clientId, swarmName);
+                    return await swarm$1.sessionPublicService.commitUserMessage(content, "user", METHOD_NAME$e, clientId, swarmName);
                 }, {
                     clientId,
                     payload,
                 });
             }
-            return await swarm$1.sessionPublicService.commitUserMessage(content, "user", METHOD_NAME$j, clientId, swarmName);
+            return await swarm$1.sessionPublicService.commitUserMessage(content, "user", METHOD_NAME$e, clientId, swarmName);
         }),
         delay,
     });
@@ -17074,7 +17530,7 @@ session.rate = (clientId, swarmName, { delay = SCHEDULED_DELAY, onDispose } = {}
 };
 
 /** @private Constant defining the method name for logging purposes */
-const METHOD_NAME$i = "function.common.hasSession";
+const METHOD_NAME$d = "function.common.hasSession";
 /**
  * Checks if a session exists for the given client ID.
  *
@@ -17086,35 +17542,11 @@ const METHOD_NAME$i = "function.common.hasSession";
  */
 const hasSession = (clientId) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$i, { clientId });
+        swarm$1.loggerService.log(METHOD_NAME$d, { clientId });
     return swarm$1.sessionValidationService.hasSession(clientId);
 };
 
-/**
- * @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$h = "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.
- * Logs the operation if enabled by global configuration.
- * @param {string} clientId - The unique identifier of the client whose navigation route is being checked.
- * @param {AgentName} agentName - The name of the agent to check within the navigation route.
- * @returns {Promise<boolean>} A promise resolving to true if the agent is in the navigation route, false otherwise.
- */
-const hasNavigation = async (clientId, agentName) => {
-    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$h, { clientId });
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$h);
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$h);
-    const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    return swarm$1.navigationValidationService
-        .getNavigationRoute(clientId, swarmName)
-        .has(agentName);
-};
-
-const METHOD_NAME$g = "function.common.getAgentName";
+const METHOD_NAME$c = "function.common.getAgentName";
 /**
  * Retrieves the name of the active agent for a given client session in a swarm.
  *
@@ -17132,18 +17564,18 @@ const METHOD_NAME$g = "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$g, {
+        swarm$1.loggerService.log(METHOD_NAME$c, {
             clientId,
         });
     // Validate the session and swarm to ensure they exist and are accessible
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$g);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$c);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$g);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$c);
     // Retrieve the active agent name via the swarm public service
-    return await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$g, clientId, swarmName);
+    return await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$c, clientId, swarmName);
 });
 
-const METHOD_NAME$f = "function.common.getAgentHistory";
+const METHOD_NAME$b = "function.common.getAgentHistory";
 /**
  * Retrieves the history prepared for a specific agent, incorporating rescue algorithm tweaks.
  *
@@ -17162,22 +17594,22 @@ const METHOD_NAME$f = "function.common.getAgentHistory";
 const getAgentHistory = beginContext(async (clientId, agentName) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$f, {
+        swarm$1.loggerService.log(METHOD_NAME$b, {
             clientId,
             agentName,
         });
     // Validate the session and agent to ensure they exist and are accessible
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$f);
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$f);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$b);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$b);
     // Retrieve the agent's prompt configuration from the agent schema service
     const { prompt } = swarm$1.agentSchemaService.get(agentName);
     // Fetch the agent's history using the prompt and rescue tweaks via the history public service
-    const history = await swarm$1.historyPublicService.toArrayForAgent(prompt, METHOD_NAME$f, clientId, agentName);
+    const history = await swarm$1.historyPublicService.toArrayForAgent(prompt, METHOD_NAME$b, clientId, agentName);
     // Return a shallow copy of the history array
     return [...history];
 });
 
-const METHOD_NAME$e = "function.common.getSessionMode";
+const METHOD_NAME$a = "function.common.getSessionMode";
 /**
  * Retrieves the session mode for a given client session in a swarm.
  *
@@ -17195,18 +17627,18 @@ const METHOD_NAME$e = "function.common.getSessionMode";
 const getSessionMode = beginContext(async (clientId) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$e, {
+        swarm$1.loggerService.log(METHOD_NAME$a, {
             clientId,
         });
     // Validate the session and swarm to ensure they exist and are accessible
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$e);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$a);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$e);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$a);
     // Retrieve the session mode from the session validation service
     return swarm$1.sessionValidationService.getSessionMode(clientId);
 });
 
-const METHOD_NAME$d = "function.common.getSessionContext";
+const METHOD_NAME$9 = "function.common.getSessionContext";
 /**
  * Retrieves the session context for the current execution environment.
  *
@@ -17223,7 +17655,7 @@ const METHOD_NAME$d = "function.common.getSessionContext";
 const getSessionContext = async () => {
     // Log the operation if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$d);
+        swarm$1.loggerService.log(METHOD_NAME$9);
     // Determine the method context, if active
     const methodContext = MethodContextService.hasContext()
         ? swarm$1.methodContextService.context
@@ -17234,99 +17666,39 @@ const getSessionContext = async () => {
         : null;
     // Derive the client ID from either the method or execution context, if available
     const clientId = methodContext?.clientId ?? executionContext?.clientId;
-    // Return the constructed session context
-    return {
-        clientId,
-        processId: GLOBAL_CONFIG.CC_PROCESS_UUID,
-        methodContext,
-        executionContext,
-    };
-};
-
-/**
- * @private Constant defining the method name for logging purposes.
- * Used as an identifier in log messages to track calls to `getNavigationRoute`.
- */
-const METHOD_NAME$c = "function.common.getNavigationRoute";
-/**
- * Retrieves the navigation route for a given client and swarm.
- * Delegates to `NavigationValidationService.getNavigationRoute` to obtain a `Set` of visited agent names,
- * with optional logging based on global configuration.
- * @param {string} clientId - The unique identifier of the client requesting the navigation route.
- * @param {SwarmName} swarmName - The name of the swarm context for which the route is retrieved.
- * @returns {Set<string>} A set of `AgentName`s representing the visited agents in the navigation route.
- */
-const getNavigationRoute = (clientId, swarmName) => {
-    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$c, {
-            clientId,
-            swarmName,
-        });
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$c);
-    return swarm$1.navigationValidationService.getNavigationRoute(clientId, swarmName);
-};
-
-const METHOD_NAME$b = "function.history.getRawHistory";
-/**
- * Retrieves the raw, unmodified history for a given client session.
- *
- * This function fetches the complete history associated with a client’s active agent in a swarm session, without any filtering or modifications.
- * It is wrapped in `beginContext` for a clean execution environment and logs the operation if enabled via `GLOBAL_CONFIG`. The function validates
- * the session and swarm, retrieves the current agent, and uses `historyPublicService.toArrayForRaw` to obtain the raw history as an array.
- * The result is a fresh copy of the history array.
- *
- * @param {string} clientId - The unique identifier of the client session whose raw history is to be retrieved.
- * @param {string} [methodName="function.history.getRawHistory"] - The name of the calling method, used for validation and logging (defaults to `METHOD_NAME`).
- * @returns {Promise<object[]>} A promise that resolves to an array containing the raw history entries.
- * @throws {Error} If session or swarm validation fails, or if history retrieval encounters an issue.
- * @example
- * const rawHistory = await getRawHistory("client-123");
- * console.log(rawHistory); // Outputs the full raw history array
- */
-const getRawHistory = beginContext(async (clientId, methodName = METHOD_NAME$b) => {
-    // Log the operation details if logging is enabled in GLOBAL_CONFIG
-    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$b, {
-            clientId,
-        });
-    // Validate the session and swarm
-    swarm$1.sessionValidationService.validate(clientId, methodName);
-    const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, methodName);
-    // Get the current agent and fetch raw history
-    const agentName = await swarm$1.swarmPublicService.getAgentName(methodName, clientId, swarmName);
-    const history = await swarm$1.historyPublicService.toArrayForRaw(methodName, clientId, agentName);
-    return [...history];
-});
+    // Return the constructed session context
+    return {
+        clientId,
+        processId: GLOBAL_CONFIG.CC_PROCESS_UUID,
+        methodContext,
+        executionContext,
+    };
+};
 
-const METHOD_NAME$a = "function.history.getLastUserMessage";
 /**
- * Retrieves the content of the most recent user message from a client's session history.
- *
- * This function fetches the raw history for a specified client using `getRawHistory` and finds the last entry where the role is "user" and the mode
- * is "user". It is wrapped in `beginContext` for a clean execution environment and logs the operation if enabled via `GLOBAL_CONFIG`. The result is
- * the content of the last user message as a string, or `null` if no matching user message exists in the history.
- *
- * @param {string} clientId - The unique identifier of the client session whose last user message is to be retrieved.
- * @returns {Promise<string | null>} A promise that resolves to the content of the last user message, or `null` if none is found.
- * @throws {Error} If `getRawHistory` fails due to session validation or history retrieval issues.
- * @example
- * const lastMessage = await getLastUserMessage("client-123");
- * console.log(lastMessage); // Outputs the last user message or null
+ * @private Constant defining the method name for logging purposes.
+ * Used as an identifier in log messages to track calls to `getNavigationRoute`.
  */
-const getLastUserMessage = beginContext(async (clientId) => {
-    // Log the operation details if logging is enabled in GLOBAL_CONFIG
+const METHOD_NAME$8 = "function.common.getNavigationRoute";
+/**
+ * Retrieves the navigation route for a given client and swarm.
+ * Delegates to `NavigationValidationService.getNavigationRoute` to obtain a `Set` of visited agent names,
+ * with optional logging based on global configuration.
+ * @param {string} clientId - The unique identifier of the client requesting the navigation route.
+ * @param {SwarmName} swarmName - The name of the swarm context for which the route is retrieved.
+ * @returns {Set<string>} A set of `AgentName`s representing the visited agents in the navigation route.
+ */
+const getNavigationRoute = (clientId, swarmName) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$a, {
+        swarm$1.loggerService.log(METHOD_NAME$8, {
             clientId,
+            swarmName,
         });
-    // Fetch raw history and find the last user message
-    const history = await getRawHistory(clientId, METHOD_NAME$a);
-    const last = history.findLast(({ role, mode }) => role === "user" && mode === "user");
-    return last ? last.content : null;
-});
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$8);
+    return swarm$1.navigationValidationService.getNavigationRoute(clientId, swarmName);
+};
 
-const METHOD_NAME$9 = "function.history.getUserHistory";
+const METHOD_NAME$7 = "function.history.getUserHistory";
 /**
  * Retrieves the user-specific history entries for a given client session.
  *
@@ -17344,15 +17716,15 @@ const METHOD_NAME$9 = "function.history.getUserHistory";
 const getUserHistory = beginContext(async (clientId) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$9, {
+        swarm$1.loggerService.log(METHOD_NAME$7, {
             clientId,
         });
     // Fetch raw history and filter for user role and mode
-    const history = await getRawHistory(clientId, METHOD_NAME$9);
+    const history = await getRawHistory(clientId, METHOD_NAME$7);
     return history.filter(({ role, mode }) => role === "user" && mode === "user");
 });
 
-const METHOD_NAME$8 = "function.history.getAssistantHistory";
+const METHOD_NAME$6 = "function.history.getAssistantHistory";
 /**
  * Retrieves the assistant's history entries for a given client session.
  *
@@ -17370,15 +17742,15 @@ const METHOD_NAME$8 = "function.history.getAssistantHistory";
 const getAssistantHistory = beginContext(async (clientId) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$8, {
+        swarm$1.loggerService.log(METHOD_NAME$6, {
             clientId,
         });
     // Fetch raw history and filter for assistant role
-    const history = await getRawHistory(clientId, METHOD_NAME$8);
+    const history = await getRawHistory(clientId, METHOD_NAME$6);
     return history.filter(({ role }) => role === "assistant");
 });
 
-const METHOD_NAME$7 = "function.history.getLastAssistantMessage";
+const METHOD_NAME$5 = "function.history.getLastAssistantMessage";
 /**
  * Retrieves the content of the most recent assistant message from a client's session history.
  *
@@ -17396,16 +17768,16 @@ const METHOD_NAME$7 = "function.history.getLastAssistantMessage";
 const getLastAssistantMessage = beginContext(async (clientId) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$7, {
+        swarm$1.loggerService.log(METHOD_NAME$5, {
             clientId,
         });
     // Fetch raw history and find the last assistant message
-    const history = await getRawHistory(clientId, METHOD_NAME$7);
+    const history = await getRawHistory(clientId, METHOD_NAME$5);
     const last = history.findLast(({ role }) => role === "assistant");
     return last ? last.content : null;
 });
 
-const METHOD_NAME$6 = "function.history.getLastSystemMessage";
+const METHOD_NAME$4 = "function.history.getLastSystemMessage";
 /**
  * Retrieves the content of the most recent system message from a client's session history.
  *
@@ -17423,16 +17795,16 @@ const METHOD_NAME$6 = "function.history.getLastSystemMessage";
 const getLastSystemMessage = beginContext(async (clientId) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$6, {
+        swarm$1.loggerService.log(METHOD_NAME$4, {
             clientId,
         });
     // Fetch raw history and find the last system message
-    const history = await getRawHistory(clientId, METHOD_NAME$6);
+    const history = await getRawHistory(clientId, METHOD_NAME$4);
     const last = history.findLast(({ role }) => role === "system");
     return last ? last.content : null;
 });
 
-const METHOD_NAME$5 = "function.event.listenEvent";
+const METHOD_NAME$3 = "function.event.listenEvent";
 /**
  * Set of reserved event source names that cannot be used for custom events.
  * @constant {Set<EventSource>}
@@ -17468,7 +17840,7 @@ const DISALLOWED_EVENT_SOURCE_LIST$2 = new Set([
 const event = beginContext((clientId, topicName, payload) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$5, {
+        swarm$1.loggerService.log(METHOD_NAME$3, {
             clientId,
         });
     // Check if the topic name is reserved
@@ -17483,7 +17855,7 @@ const event = beginContext((clientId, topicName, payload) => {
     });
 });
 
-const METHOD_NAME$4 = "function.event.listenEvent";
+const METHOD_NAME$2 = "function.event.listenEvent";
 /**
  * Set of reserved event source names that cannot be used for custom event topics.
  * @constant {Set<EventSource>}
@@ -17535,7 +17907,7 @@ const validateClientId$g = (clientId) => {
 const listenEvent = beginContext((clientId, topicName, fn) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$4, {
+        swarm$1.loggerService.log(METHOD_NAME$2, {
             clientId,
         });
     // Check if the topic name is reserved
@@ -17548,7 +17920,7 @@ const listenEvent = beginContext((clientId, topicName, fn) => {
     return swarm$1.busService.subscribe(clientId, topicName, functoolsKit.queued(async ({ payload }) => await fn(payload)));
 });
 
-const METHOD_NAME$3 = "function.event.listenEventOnce";
+const METHOD_NAME$1 = "function.event.listenEventOnce";
 /**
  * Set of reserved event source names that cannot be used for custom event topics.
  * @constant {Set<EventSource>}
@@ -17606,7 +17978,7 @@ const validateClientId$f = (clientId) => {
 const listenEventOnce = beginContext((clientId, topicName, filterFn, fn) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$3, {
+        swarm$1.loggerService.log(METHOD_NAME$1, {
             clientId,
         });
     // Check if the topic name is reserved
@@ -17619,125 +17991,19 @@ const listenEventOnce = beginContext((clientId, topicName, filterFn, fn) => {
     return swarm$1.busService.once(clientId, topicName, ({ payload }) => filterFn(payload), functoolsKit.queued(async ({ payload }) => await fn(payload)));
 });
 
-const METHOD_NAME$2 = "function.navigate.changeToAgent";
-/**
- * Time-to-live for the change agent function in milliseconds.
- * Defines how long the cached change agent function remains valid before expiring.
- * @constant {number}
- */
-const CHANGE_AGENT_TTL$2 = 15 * 60 * 1000;
-/**
- * Garbage collection interval for the change agent function in milliseconds.
- * Specifies the frequency at which expired TTL entries are cleaned up.
- * @constant {number}
- */
-const CHANGE_AGENT_GC$2 = 60 * 1000;
-/**
- * Creates a change agent function with time-to-live (TTL) and queuing capabilities.
- *
- * This factory function generates a queued, TTL-limited function to handle agent changes for a specific client session,
- * ensuring operations are executed sequentially and cached results are reused within the TTL period.
- *
- * @function
- * @param {string} clientId - The unique identifier of the client session.
- * @returns {TChangeToAgentRun} A function that performs the agent change operation with queuing and TTL.
- */
-const createChangeToAgent = functoolsKit.ttl((clientId) => functoolsKit.queued(async (methodName, agentName, swarmName) => {
-    if (!swarm$1.navigationValidationService.shouldNavigate(agentName, clientId, swarmName)) {
-        console.warn(`function "changeToAgent" skipped due to the circular route found clientId=${clientId} swarmName=${swarmName} agentNameTo=${agentName}`);
-        return false;
-    }
-    // Notify all agents in the swarm of the change
-    await Promise.all(swarm$1.swarmValidationService
-        .getAgentList(swarmName)
-        .map(async (agentName) => {
-        await swarm$1.agentPublicService.commitAgentChange(methodName, clientId, agentName);
-    }));
-    {
-        // Dispose of the current agent's resources and set up the new agent
-        const agentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$2, clientId, swarmName);
-        await swarm$1.agentPublicService.dispose(methodName, clientId, agentName);
-        await swarm$1.historyPublicService.dispose(methodName, clientId, agentName);
-        await swarm$1.swarmPublicService.setAgentRef(methodName, clientId, swarmName, agentName, await swarm$1.agentPublicService.createAgentRef(methodName, clientId, agentName));
-    }
-    // Set the new agent as the active agent
-    await swarm$1.swarmPublicService.setAgentName(agentName, methodName, clientId, swarmName);
-    return true;
-}), {
-    key: ([clientId]) => `${clientId}`,
-    timeout: CHANGE_AGENT_TTL$2,
-});
-/**
- * Creates a garbage collector for the change agent function.
- *
- * This function sets up a singleton interval-based garbage collector to periodically clean up expired TTL entries from `createChangeToAgent`.
- *
- * @function
- * @returns {Promise<void>} A promise that resolves when the garbage collector is initialized.
- */
-const createGc$2 = functoolsKit.singleshot(async () => {
-    setInterval(createChangeToAgent.gc, CHANGE_AGENT_GC$2);
-});
-/**
- * Changes the active agent for a given client session in a swarm.
- *
- * This function facilitates switching the active agent in a swarm session, validating the session and agent dependencies,
- * logging the operation if enabled, and executing the change using a TTL-limited, queued runner.
- * The execution is wrapped in `beginContext` to ensure it runs outside of existing method and execution contexts.
- *
- * @param {AgentName} agentName - The name of the agent to switch to.
- * @param {string} clientId - The unique identifier of the client session.
- * @returns {Promise<boolean>} A promise that resolves when the agent change is complete. If it resolved false, the navigation is canceled due to recursion
- * @throws {Error} If session or agent validation fails, or if the agent change process encounters an error.
- * @example
- * await changeToAgent("AgentX", "client-123");
- */
-const changeToAgent = beginContext(async (agentName, clientId) => {
-    // Log the operation details if logging is enabled in GLOBAL_CONFIG
-    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$2, {
-            agentName,
-            clientId,
-        });
-    const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    {
-        // Validate session, agent, and dependencies
-        swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$2);
-        swarm$1.agentValidationService.validate(agentName, METHOD_NAME$2);
-        const activeAgent = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$2, clientId, swarmName);
-        if (!swarm$1.agentValidationService.hasDependency(activeAgent, agentName)) {
-            console.error(`agent-swarm missing dependency detected for activeAgent=${activeAgent} dependencyAgent=${agentName}`);
-        }
-    }
-    if (!swarm$1.swarmValidationService.getAgentSet(swarmName).has(agentName)) {
-        GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-            swarm$1.loggerService.log('function "changeToAgent" skipped due to the agent is not in the swarm', {
-                agentName,
-                clientId,
-                swarmName,
-            });
-        console.warn(`function "changeToAgent" skipped due to the agent is not in the swarm clientId=${clientId} agentName=${agentName} swarmName=${swarmName}`);
-        return false;
-    }
-    // Execute the agent change with TTL and queuing
-    const run = await createChangeToAgent(clientId);
-    createGc$2();
-    return await run(METHOD_NAME$2, agentName, swarmName);
-});
-
-const METHOD_NAME$1 = "function.navigate.changeToPrevAgent";
+const METHOD_NAME = "function.navigate.changeToPrevAgent";
 /**
  * Time-to-live for the change agent function in milliseconds.
  * Defines how long the cached change agent function remains valid before expiring.
  * @constant {number}
  */
-const CHANGE_AGENT_TTL$1 = 15 * 60 * 1000;
+const CHANGE_AGENT_TTL = 15 * 60 * 1000;
 /**
  * Garbage collection interval for the change agent function in milliseconds.
  * Specifies the frequency at which expired TTL entries are cleaned up.
  * @constant {number}
  */
-const CHANGE_AGENT_GC$1 = 60 * 1000;
+const CHANGE_AGENT_GC = 60 * 1000;
 /**
  * Creates a change agent function with time-to-live (TTL) and queuing capabilities for switching to the previous agent.
  *
@@ -17760,7 +18026,7 @@ const createChangeToPrevAgent = functoolsKit.ttl((clientId) => functoolsKit.queu
     }));
     {
         // Dispose of the current agent's resources and set up the new agent
-        const agentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1, clientId, swarmName);
+        const agentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME, clientId, swarmName);
         await swarm$1.agentPublicService.dispose(methodName, clientId, agentName);
         await swarm$1.historyPublicService.dispose(methodName, clientId, agentName);
         await swarm$1.swarmPublicService.setAgentRef(methodName, clientId, swarmName, agentName, await swarm$1.agentPublicService.createAgentRef(methodName, clientId, agentName));
@@ -17770,7 +18036,7 @@ const createChangeToPrevAgent = functoolsKit.ttl((clientId) => functoolsKit.queu
     return true;
 }), {
     key: ([clientId]) => `${clientId}`,
-    timeout: CHANGE_AGENT_TTL$1,
+    timeout: CHANGE_AGENT_TTL,
 });
 /**
  * Creates a garbage collector for the change agent function.
@@ -17780,8 +18046,8 @@ const createChangeToPrevAgent = functoolsKit.ttl((clientId) => functoolsKit.queu
  * @function
  * @returns {Promise<void>} A promise that resolves when the garbage collector is initialized.
  */
-const createGc$1 = functoolsKit.singleshot(async () => {
-    setInterval(createChangeToPrevAgent.gc, CHANGE_AGENT_GC$1);
+const createGc = functoolsKit.singleshot(async () => {
+    setInterval(createChangeToPrevAgent.gc, CHANGE_AGENT_GC);
 });
 /**
  * Navigates back to the previous or default agent for a given client session in a swarm.
@@ -17797,110 +18063,20 @@ const createGc$1 = functoolsKit.singleshot(async () => {
  * await changeToPrevAgent("client-123");
  */
 const changeToPrevAgent = 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$1, {
-            clientId,
-        });
-    const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    const agentName = await swarm$1.swarmPublicService.navigationPop(METHOD_NAME$1, clientId, swarmName);
-    {
-        // Validate session and the retrieved agent
-        swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1);
-        swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1);
-    }
-    // Execute the agent change with TTL and queuing
-    const run = await createChangeToPrevAgent(clientId);
-    createGc$1();
-    return await run(METHOD_NAME$1, agentName, swarmName);
-});
-
-const METHOD_NAME = "function.navigate.changeToDefaultAgent";
-/**
- * Time-to-live for the change agent function in milliseconds.
- * Defines how long the cached change agent function remains valid before expiring.
- * @constant {number}
- */
-const CHANGE_AGENT_TTL = 15 * 60 * 1000;
-/**
- * Garbage collection interval for the change agent function in milliseconds.
- * Specifies the frequency at which expired TTL entries are cleaned up.
- * @constant {number}
- */
-const CHANGE_AGENT_GC = 60 * 1000;
-/**
- * Creates a change agent function with time-to-live (TTL) and queuing capabilities for switching to the default agent.
- *
- * This factory function generates a queued, TTL-limited function to handle agent changes to the default agent for a specific client session,
- * ensuring operations are executed sequentially and cached results are reused within the TTL period.
- *
- * @function
- * @param {string} clientId - The unique identifier of the client session.
- * @returns {TChangeToDefaultAgentRun} A function that performs the default agent change operation with queuing and TTL.
- */
-const createChangeToDefaultAgent = functoolsKit.ttl((clientId) => functoolsKit.queued(async (methodName, agentName, swarmName) => {
-    if (!swarm$1.navigationValidationService.shouldNavigate(agentName, clientId, swarmName)) {
-        return false;
-    }
-    // Notify all agents in the swarm of the change
-    await Promise.all(swarm$1.swarmValidationService
-        .getAgentList(swarmName)
-        .map(async (agentName) => {
-        await swarm$1.agentPublicService.commitAgentChange(methodName, clientId, agentName);
-    }));
-    {
-        // Dispose of the current agent's resources and set up the new default agent
-        const agentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME, clientId, swarmName);
-        await swarm$1.agentPublicService.dispose(methodName, clientId, agentName);
-        await swarm$1.historyPublicService.dispose(methodName, clientId, agentName);
-        await swarm$1.swarmPublicService.setAgentRef(methodName, clientId, swarmName, agentName, await swarm$1.agentPublicService.createAgentRef(methodName, clientId, agentName));
-    }
-    // Set the default agent as the active agent
-    await swarm$1.swarmPublicService.setAgentName(agentName, methodName, clientId, swarmName);
-    return true;
-}), {
-    key: ([clientId]) => `${clientId}`,
-    timeout: CHANGE_AGENT_TTL,
-});
-/**
- * Creates a garbage collector for the change agent function.
- *
- * This function sets up a singleton interval-based garbage collector to periodically clean up expired TTL entries from `createChangeToDefaultAgent`.
- *
- * @function
- * @returns {Promise<void>} A promise that resolves when the garbage collector is initialized.
- */
-const createGc = functoolsKit.singleshot(async () => {
-    setInterval(createChangeToDefaultAgent.gc, CHANGE_AGENT_GC);
-});
-/**
- * Navigates back to the default agent for a given client session in a swarm.
- *
- * This function switches the active agent to the default agent defined in the swarm schema for the specified client session.
- * It validates the session and default agent, logs the operation if enabled, and executes the change using a TTL-limited, queued runner.
- * The execution is wrapped in `beginContext` to ensure it runs outside of existing method and execution contexts.
- *
- * @param {string} clientId - The unique identifier of the client session.
- * @returns {Promise<boolean>} A promise that resolves when the default agent change is complete. If navigation stack contains recursion being canceled
- * @throws {Error} If session or agent validation fails, or if the agent change process encounters an error.
- * @example
- * await changeToDefaultAgent("client-123");
- */
-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, {
             clientId,
         });
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    const { defaultAgent: agentName } = swarm$1.swarmSchemaService.get(swarmName);
+    const agentName = await swarm$1.swarmPublicService.navigationPop(METHOD_NAME, clientId, swarmName);
     {
-        // Validate session and default agent
+        // Validate session and the retrieved agent
         swarm$1.sessionValidationService.validate(clientId, METHOD_NAME);
         swarm$1.agentValidationService.validate(agentName, METHOD_NAME);
     }
     // Execute the agent change with TTL and queuing
-    const run = await createChangeToDefaultAgent(clientId);
+    const run = await createChangeToPrevAgent(clientId);
     createGc();
     return await run(METHOD_NAME, agentName, swarmName);
 });
@@ -19962,6 +20138,8 @@ exports.commitToolOutputForce = commitToolOutputForce;
 exports.commitUserMessage = commitUserMessage;
 exports.commitUserMessageForce = commitUserMessageForce;
 exports.complete = complete;
+exports.createNavigateToAgent = createNavigateToAgent;
+exports.createNavigateToTriageAgent = createNavigateToTriageAgent;
 exports.disposeConnection = disposeConnection;
 exports.dumpAgent = dumpAgent;
 exports.dumpClientPerformance = dumpClientPerformance;