agent-swarm-kit 1.1.46 → 1.1.48

package/build/index.cjs

@@ -4835,22 +4835,9 @@ class ClientOperator {
 
 const METHOD_NAME$1n = "function.commit.commitToolOutput";
 /**
- * Commits the output of a tool execution to the active agent in a swarm session.
- *
- * This function ensures that the tool output is committed only if the specified agent is still the active agent in the swarm session.
- * It performs validation checks on the agent, 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.
- * @param {AgentName} agentName - The name of the agent committing the tool output.
- * @returns {Promise<void>} A promise that resolves when the tool output is successfully committed, or immediately if the operation is skipped due to an agent change.
- * @throws {Error} If validation fails (e.g., invalid agent, session, or swarm) or if the session public service encounters an error during the commit operation.
- * @example
- * await commitToolOutput("tool-123", "Tool execution result", "client-456", "AgentX");
+ * Function implementation
  */
-const commitToolOutput = beginContext(async (toolId, content, clientId, agentName) => {
+const commitToolOutputInternal = 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$1n, {
@@ -4880,26 +4867,31 @@ const commitToolOutput = beginContext(async (toolId, content, clientId, agentNam
     // Commit the tool output to the session via the session public service
     await swarm$1.sessionPublicService.commitToolOutput(toolId, content, METHOD_NAME$1n, clientId, swarmName);
 });
-
-const METHOD_NAME$1m = "function.target.execute";
 /**
- * Sends a message to the active agent in a swarm session as if it originated from the client side.
+ * Commits the output of a tool execution to the active agent in a swarm session.
  *
- * This function executes a command or message on behalf of the specified agent within a swarm session, designed for scenarios like reviewing tool output
- * or initiating a model-to-client conversation. It validates the agent and session, checks if the specified agent is still active, and executes the content
- * with performance tracking and event bus notifications. The execution is wrapped in `beginContext` for a clean environment and runs within an
- * `ExecutionContextService` context for metadata tracking. If the active agent has changed, the operation is skipped.
+ * This function ensures that the tool output is committed only if the specified agent is still the active agent in the swarm session.
+ * It performs validation checks on the agent, 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} content - The content or command to be executed by the agent.
- * @param {string} clientId - The unique identifier of the client session requesting the execution.
- * @param {AgentName} agentName - The name of the agent intended to execute the command.
- * @returns {Promise<string>} A promise that resolves to the result of the execution, or an empty string if skipped due to an agent change.
- * @throws {Error} If agent, session, or swarm validation fails, or if the execution process encounters an error.
+ * @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.
+ * @param {AgentName} agentName - The name of the agent committing the tool output.
+ * @returns {Promise<void>} A promise that resolves when the tool output is successfully committed, or immediately if the operation is skipped due to an agent change.
+ * @throws {Error} If validation fails (e.g., invalid agent, session, or swarm) or if the session public service encounters an error during the commit operation.
  * @example
- * const result = await execute("Review this output", "client-123", "AgentX");
- * console.log(result); // Outputs the agent's response or "" if skipped
+ * await commitToolOutput("tool-123", "Tool execution result", "client-456", "AgentX");
+ */
+function commitToolOutput(toolId, content, clientId, agentName) {
+    return commitToolOutputInternal(toolId, content, clientId, agentName);
+}
+
+const METHOD_NAME$1m = "function.target.execute";
+/**
+ * Function implementation
  */
-const execute = beginContext(async (content, clientId, agentName) => {
+const executeInternal = 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 &&
@@ -4953,23 +4945,33 @@ const execute = beginContext(async (content, clientId, agentName) => {
         processId: GLOBAL_CONFIG.CC_PROCESS_UUID,
     });
 });
+/**
+ * Sends a message to the active agent in a swarm session as if it originated from the client side.
+ *
+ * This function executes a command or message on behalf of the specified agent within a swarm session, designed for scenarios like reviewing tool output
+ * or initiating a model-to-client conversation. It validates the agent and session, checks if the specified agent is still active, and executes the content
+ * with performance tracking and event bus notifications. The execution is wrapped in `beginContext` for a clean environment and runs within an
+ * `ExecutionContextService` context for metadata tracking. If the active agent has changed, the operation is skipped.
+ *
+ * @param {string} content - The content or command to be executed by the agent.
+ * @param {string} clientId - The unique identifier of the client session requesting the execution.
+ * @param {AgentName} agentName - The name of the agent intended to execute the command.
+ * @returns {Promise<string>} A promise that resolves to the result of the execution, or an empty string if skipped due to an agent change.
+ * @throws {Error} If agent, session, or swarm validation fails, or if the execution process encounters an error.
+ * @example
+ * const result = await execute("Review this output", "client-123", "AgentX");
+ * console.log(result); // Outputs the agent's response or "" if skipped
+ */
+function execute(content, clientId, agentName) {
+    return executeInternal(content, clientId, agentName);
+}
 
 /** @private Constant defining the method name for logging and validation context */
 const METHOD_NAME$1l = "function.commit.commitFlush";
 /**
- * Commits a flush of agent history for a specific client and agent in the swarm system.
- * Validates the agent, session, and swarm, ensuring the current agent matches the provided agent before flushing the history.
- * Runs within a beginContext wrapper for execution context management, logging operations via LoggerService.
- * Integrates with AgentValidationService (agent validation), SessionValidationService (session and swarm retrieval),
- * SwarmValidationService (swarm validation), SwarmPublicService (agent retrieval), SessionPublicService (history flush),
- * and LoggerService (logging). Complements functions like commitAssistantMessage by clearing agent history rather than adding messages.
- *
- * @param {string} clientId - The ID of the client associated with the session, validated against active sessions.
- * @param {string} agentName - The name of the agent whose history is to be flushed, validated against registered agents.
- * @returns {Promise<void>} A promise that resolves when the history flush is committed or skipped (e.g., agent mismatch).
- * @throws {Error} If agent, session, or swarm validation fails, propagated from respective validation services.
+ * Function implementation
  */
-const commitFlush = beginContext(async (clientId, agentName) => {
+const commitFlushInternal = beginContext(async (clientId, agentName) => {
     // Log the flush attempt if enabled
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
         swarm$1.loggerService.log(METHOD_NAME$1l, {
@@ -4997,25 +4999,28 @@ const commitFlush = beginContext(async (clientId, agentName) => {
     // Commit the flush of agent history via SessionPublicService
     await swarm$1.sessionPublicService.commitFlush(METHOD_NAME$1l, clientId, swarmName);
 });
+/**
+ * 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.
+ * Runs within a beginContext wrapper for execution context management, logging operations via LoggerService.
+ * Integrates with AgentValidationService (agent validation), SessionValidationService (session and swarm retrieval),
+ * SwarmValidationService (swarm validation), SwarmPublicService (agent retrieval), SessionPublicService (history flush),
+ * and LoggerService (logging). Complements functions like commitAssistantMessage by clearing agent history rather than adding messages.
+ *
+ * @param {string} clientId - The ID of the client associated with the session, validated against active sessions.
+ * @param {string} agentName - The name of the agent whose history is to be flushed, validated against registered agents.
+ * @returns {Promise<void>} A promise that resolves when the history flush is committed or skipped (e.g., agent mismatch).
+ * @throws {Error} If agent, session, or swarm validation fails, propagated from respective validation services.
+ */
+function commitFlush(clientId, agentName) {
+    return commitFlushInternal(clientId, agentName);
+}
 
 const METHOD_NAME$1k = "function.target.emit";
 /**
- * Emits a string as model output without executing an incoming message, with agent activity validation.
- *
- * This function directly emits a provided string as output from the swarm session, bypassing message execution, and is designed exclusively
- * for sessions established via `makeConnection`. It validates the session, swarm, and specified agent, ensuring the agent is still active
- * before emitting. If the active agent has changed, the operation is skipped. The execution is wrapped in `beginContext` for a clean environment,
- * logs the operation if enabled, and throws an error if the session mode is not "makeConnection".
- *
- * @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.
- * @param {AgentName} agentName - The name of the agent intended to emit the content.
- * @returns {Promise<void>} A promise that resolves when the content is emitted, or resolves early if skipped due to an agent change.
- * @throws {Error} If the session mode is not "makeConnection", or if agent, session, or swarm validation fails.
- * @example
- * await emit("Direct output", "client-123", "AgentX"); // Emits "Direct output" if AgentX is active
+ * Function implementation
  */
-const emit = beginContext(async (content, clientId, agentName) => {
+const emitInternal = 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$1k, {
@@ -5042,23 +5047,31 @@ const emit = beginContext(async (content, clientId, agentName) => {
     // Emit the content directly via the session public service
     return await swarm$1.sessionPublicService.emit(content, METHOD_NAME$1k, clientId, swarmName);
 });
-
-const METHOD_NAME$1j = "function.common.getAgentName";
 /**
- * Retrieves the name of the active agent for a given client session in a swarm.
+ * Emits a string as model output without executing an incoming message, with agent activity validation.
  *
- * This function fetches the name of the currently active agent associated with the specified client session within a swarm.
- * It validates the client session and swarm, logs the operation if enabled, and delegates the retrieval to the swarm public service.
- * The execution is wrapped in `beginContext` to ensure it runs outside of existing method and execution contexts, providing a clean execution environment.
+ * This function directly emits a provided string as output from the swarm session, bypassing message execution, and is designed exclusively
+ * for sessions established via `makeConnection`. It validates the session, swarm, and specified agent, ensuring the agent is still active
+ * before emitting. If the active agent has changed, the operation is skipped. The execution is wrapped in `beginContext` for a clean environment,
+ * logs the operation if enabled, and throws an error if the session mode is not "makeConnection".
  *
- * @param {string} clientId - The unique identifier of the client session whose active agent name is being retrieved.
- * @returns {Promise<string>} A promise that resolves to the name of the active agent (`AgentName`) associated with the client session.
- * @throws {Error} If the client session is invalid, the swarm validation fails, or the swarm public service encounters an error during retrieval.
+ * @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.
+ * @param {AgentName} agentName - The name of the agent intended to emit the content.
+ * @returns {Promise<void>} A promise that resolves when the content is emitted, or resolves early if skipped due to an agent change.
+ * @throws {Error} If the session mode is not "makeConnection", or if agent, session, or swarm validation fails.
  * @example
- * const agentName = await getAgentName("client-123");
- * console.log(agentName); // Outputs "AgentX"
+ * await emit("Direct output", "client-123", "AgentX"); // Emits "Direct output" if AgentX is active
+ */
+function emit(content, clientId, agentName) {
+    return emitInternal(content, clientId, agentName);
+}
+
+const METHOD_NAME$1j = "function.common.getAgentName";
+/**
+ * Function implementation
  */
-const getAgentName = beginContext(async (clientId) => {
+const getAgentNameInternal = 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$1j, {
@@ -5071,23 +5084,30 @@ const getAgentName = beginContext(async (clientId) => {
     // Retrieve the active agent name via the swarm public service
     return await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1j, clientId, swarmName);
 });
+/**
+ * Retrieves the name of the active agent for a given client session in a swarm.
+ *
+ * This function fetches the name of the currently active agent associated with the specified client session within a swarm.
+ * It validates the client session and swarm, logs the operation if enabled, and delegates the retrieval to the swarm 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} clientId - The unique identifier of the client session whose active agent name is being retrieved.
+ * @returns {Promise<string>} A promise that resolves to the name of the active agent (`AgentName`) associated with the client session.
+ * @throws {Error} If the client session is invalid, the swarm validation fails, or the swarm public service encounters an error during retrieval.
+ * @example
+ * const agentName = await getAgentName("client-123");
+ * console.log(agentName); // Outputs "AgentX"
+ */
+function getAgentName(clientId) {
+    return getAgentNameInternal(clientId);
+}
 
 /** @private Constant defining the method name for logging and validation context */
 const METHOD_NAME$1i = "function.commit.commitStopTools";
 /**
- * Prevents the next tool from being executed for a specific client and agent in the swarm system.
- * Validates the agent, session, and swarm, ensuring the current agent matches the provided agent before stopping tool execution.
- * Runs within a beginContext wrapper for execution context management, logging operations via LoggerService.
- * Integrates with AgentValidationService (agent validation), SessionValidationService (session and swarm retrieval),
- * SwarmValidationService (swarm validation), SwarmPublicService (agent retrieval), SessionPublicService (tool execution stop),
- * ToolValidationService (tool context), and LoggerService (logging). Complements functions like commitFlush by controlling tool flow rather than clearing history.
- *
- * @param {string} clientId - The ID of the client associated with the session, validated against active sessions.
- * @param {string} agentName - The name of the agent whose next tool execution is to be stopped, validated against registered agents.
- * @returns {Promise<void>} A promise that resolves when the tool stop is committed or skipped (e.g., agent mismatch).
- * @throws {Error} If agent, session, or swarm validation fails, propagated from respective validation services.
+ * Function implementation
  */
-const commitStopTools = beginContext(async (clientId, agentName) => {
+const commitStopToolsInternal = beginContext(async (clientId, agentName) => {
     // Log the stop tools attempt if enabled
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
         swarm$1.loggerService.log(METHOD_NAME$1i, {
@@ -5115,6 +5135,22 @@ const commitStopTools = beginContext(async (clientId, agentName) => {
     // Commit the stop of the next tool execution via SessionPublicService
     await swarm$1.sessionPublicService.commitStopTools(METHOD_NAME$1i, clientId, swarmName);
 });
+/**
+ * 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.
+ * Runs within a beginContext wrapper for execution context management, logging operations via LoggerService.
+ * Integrates with AgentValidationService (agent validation), SessionValidationService (session and swarm retrieval),
+ * SwarmValidationService (swarm validation), SwarmPublicService (agent retrieval), SessionPublicService (tool execution stop),
+ * ToolValidationService (tool context), and LoggerService (logging). Complements functions like commitFlush by controlling tool flow rather than clearing history.
+ *
+ * @param {string} clientId - The ID of the client associated with the session, validated against active sessions.
+ * @param {string} agentName - The name of the agent whose next tool execution is to be stopped, validated against registered agents.
+ * @returns {Promise<void>} A promise that resolves when the tool stop is committed or skipped (e.g., agent mismatch).
+ * @throws {Error} If agent, session, or swarm validation fails, propagated from respective validation services.
+ */
+function commitStopTools(clientId, agentName) {
+    return commitStopToolsInternal(clientId, agentName);
+}
 
 const METHOD_NAME_UPDATE$2 = "McpUtils.update";
 /**
@@ -5642,15 +5678,9 @@ class AgentConnectionService {
 /** @private Constant defining the method name for logging purposes */
 const METHOD_NAME$1h = "function.common.getPayload";
 /**
- * Retrieves the payload from the current PayloadContextService context.
- * Returns null if no context is available. Logs the operation if logging is enabled.
- * @template Payload - The type of the payload object, defaults to a generic object.
- * @returns the payload data from the context, or null if no context exists.
- * @example
- * const payload = await getPayload<{ id: number }>();
- * console.log(payload); // { id: number } or null
+ * Function implementation
  */
-const getPayload = () => {
+const getPayloadInternal = () => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$1h);
     if (PayloadContextService.hasContext()) {
         const { payload } = swarm$1.payloadContextService.context;
@@ -5658,6 +5688,18 @@ const getPayload = () => {
     }
     return null;
 };
+/**
+ * Retrieves the payload from the current PayloadContextService context.
+ * Returns null if no context is available. Logs the operation if logging is enabled.
+ * @template Payload - The type of the payload object, defaults to a generic object.
+ * @returns the payload data from the context, or null if no context exists.
+ * @example
+ * const payload = await getPayload<{ id: number }>();
+ * console.log(payload); // { id: number } or null
+ */
+function getPayload() {
+    return getPayloadInternal();
+}
 
 /**
  * Class representing the history of client messages in the swarm system, implementing the IHistory interface.
@@ -17859,20 +17901,9 @@ dumpClientPerformance.runAfterExecute = beginContext(async (dirName = "./logs/cl
 /** @private Constant defining the method name for logging and validation context */
 const METHOD_NAME$1b = "function.commit.commitFlushForce";
 /**
- * Forcefully commits a flush of agent history for a specific client in the swarm system, without checking the active agent.
- * Validates the session and swarm, then proceeds with flushing the history regardless of the current agent state.
- * 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.
+ * Function implementation
  */
-const commitFlushForce = beginContext(async (clientId) => {
+const commitFlushForceInternal = beginContext(async (clientId) => {
     // Log the flush attempt if enabled
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
         swarm$1.loggerService.log(METHOD_NAME$1b, {
@@ -17887,24 +17918,29 @@ const commitFlushForce = beginContext(async (clientId) => {
     // Commit the flush of agent history via SessionPublicService without agent checks
     await swarm$1.sessionPublicService.commitFlush(METHOD_NAME$1b, clientId, swarmName);
 });
+/**
+ * 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.
+ */
+function commitFlushForce(clientId) {
+    return commitFlushForceInternal(clientId);
+}
 
 const METHOD_NAME$1a = "function.commit.commitToolOutputForce";
 /**
- * Commits the output of a tool execution to the active agent in a swarm session without checking the active agent.
- *
- * 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");
+ * Function implementation
  */
-const commitToolOutputForce = beginContext(async (toolId, content, clientId) => {
+const commitToolOutputForceInternal = 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$1a, {
@@ -17919,6 +17955,24 @@ const commitToolOutputForce = beginContext(async (toolId, content, clientId) =>
     // 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$1a, clientId, swarmName);
 });
+/**
+ * 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");
+ */
+function commitToolOutputForce(toolId, content, clientId) {
+    return commitToolOutputForceInternal(toolId, content, clientId);
+}
 
 /**
  * @private Constant defining the method name for logging and validation purposes.
@@ -17926,14 +17980,9 @@ const commitToolOutputForce = beginContext(async (toolId, content, clientId) =>
  */
 const METHOD_NAME$19 = "function.common.hasNavigation";
 /**
- * Checks if a specific agent is part of the navigation route for a given client.
- * Validates the agent and client session, retrieves the associated swarm, and queries the navigation route.
- * 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.
+ * Function implementation
  */
-const hasNavigation = async (clientId, agentName) => {
+const hasNavigationInternal = async (clientId, agentName) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
         swarm$1.loggerService.log(METHOD_NAME$19, { clientId });
     swarm$1.agentValidationService.validate(agentName, METHOD_NAME$19);
@@ -17943,8 +17992,37 @@ const hasNavigation = async (clientId, agentName) => {
         .getNavigationRoute(clientId, swarmName)
         .has(agentName);
 };
+/**
+ * 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.
+ */
+function hasNavigation(clientId, agentName) {
+    return hasNavigationInternal(clientId, agentName);
+}
 
 const METHOD_NAME$18 = "function.history.getRawHistory";
+/**
+ * Function implementation
+ */
+const getRawHistoryInternal = beginContext(async (clientId, methodName) => {
+    // Log the operation details if logging is enabled in GLOBAL_CONFIG
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
+        swarm$1.loggerService.log(METHOD_NAME$18, {
+            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];
+});
 /**
  * Retrieves the raw, unmodified history for a given client session.
  *
@@ -17961,23 +18039,25 @@ const METHOD_NAME$18 = "function.history.getRawHistory";
  * const rawHistory = await getRawHistory("client-123");
  * console.log(rawHistory); // Outputs the full raw history array
  */
-const getRawHistory = beginContext(async (clientId, methodName = METHOD_NAME$18) => {
+function getRawHistory(clientId) {
+    return getRawHistoryInternal(clientId, METHOD_NAME$18);
+}
+
+const METHOD_NAME$17 = "function.history.getLastUserMessage";
+/**
+ * Function implementation
+ */
+const getLastUserMessageInternal = 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$18, {
+        swarm$1.loggerService.log(METHOD_NAME$17, {
             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];
+    // Fetch raw history and find the last user message
+    const history = await getRawHistoryInternal(clientId, METHOD_NAME$17);
+    const last = history.findLast(({ role, mode }) => role === "user" && mode === "user");
+    return last?.content ? last.content : null;
 });
-
-const METHOD_NAME$17 = "function.history.getLastUserMessage";
 /**
  * Retrieves the content of the most recent user message from a client's session history.
  *
@@ -17992,17 +18072,9 @@ const METHOD_NAME$17 = "function.history.getLastUserMessage";
  * 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$17, {
-            clientId,
-        });
-    // Fetch raw history and find the last user message
-    const history = await getRawHistory(clientId, METHOD_NAME$17);
-    const last = history.findLast(({ role, mode }) => role === "user" && mode === "user");
-    return last?.content ? last.content : null;
-});
+function getLastUserMessage(clientId) {
+    return getLastUserMessageInternal(clientId);
+}
 
 const disposeSubject = new functoolsKit.Subject();
 
@@ -18052,19 +18124,9 @@ const createGc$3 = functoolsKit.singleshot(async () => {
     });
 });
 /**
- * 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");
+ * Function implementation
  */
-const changeToDefaultAgent = beginContext(async (clientId) => {
+const changeToDefaultAgentInternal = 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$16, {
@@ -18082,24 +18144,28 @@ const changeToDefaultAgent = beginContext(async (clientId) => {
     createGc$3();
     return await run(METHOD_NAME$16, agentName, swarmName);
 });
-
-const METHOD_NAME$15 = "function.target.emitForce";
 /**
- * Emits a string as model output without executing an incoming message or checking the active agent.
+ * Navigates back to the default agent for a given client session in a swarm.
  *
- * 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.
+ * 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} 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.
+ * @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 emitForce("Direct output", "client-123"); // Emits "Direct output" in a makeConnection session
+ * await changeToDefaultAgent("client-123");
+ */
+function changeToDefaultAgent(clientId) {
+    return changeToDefaultAgentInternal(clientId);
+}
+
+const METHOD_NAME$15 = "function.target.emitForce";
+/**
+ * Function implementation
  */
-const emitForce = beginContext(async (content, clientId) => {
+const emitForceInternal = 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$15, {
@@ -18113,25 +18179,30 @@ const emitForce = beginContext(async (content, clientId) => {
     // Emit the content directly via the session public service
     return await swarm$1.sessionPublicService.emit(content, METHOD_NAME$15, clientId, swarmName);
 });
-
-const METHOD_NAME$14 = "function.target.executeForce";
 /**
- * Sends a message to the active agent in a swarm session as if it originated from the client side, forcing execution regardless of agent activity.
+ * Emits a string as model output without executing an incoming message or checking the active agent.
  *
- * 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.
+ * 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 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.
+ * @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
- * const result = await executeForce("Force this execution", "client-123");
- * console.log(result); // Outputs the agent's response regardless of its active state
+ * await emitForce("Direct output", "client-123"); // Emits "Direct output" in a makeConnection session
+ */
+function emitForce(content, clientId) {
+    return emitForceInternal(content, clientId);
+}
+
+const METHOD_NAME$14 = "function.target.executeForce";
+/**
+ * Function implementation
  */
-const executeForce = beginContext(async (content, clientId) => {
+const executeForceInternal = 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 &&
@@ -18166,6 +18237,25 @@ const executeForce = beginContext(async (content, clientId) => {
         processId: GLOBAL_CONFIG.CC_PROCESS_UUID,
     });
 });
+/**
+ * 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
+ */
+function executeForce(content, clientId) {
+    return executeForceInternal(content, clientId);
+}
 
 const METHOD_NAME$13 = "function.template.navigateToTriageAgent";
 /**
@@ -18297,20 +18387,9 @@ const createGc$2 = functoolsKit.singleshot(async () => {
     });
 });
 /**
- * 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");
+ * Function implementation
  */
-const changeToAgent = beginContext(async (agentName, clientId) => {
+const changeToAgentInternal = 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$12, {
@@ -18342,6 +18421,23 @@ const changeToAgent = beginContext(async (agentName, clientId) => {
     createGc$2();
     return await run(METHOD_NAME$12, agentName, swarmName);
 });
+/**
+ * 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");
+ */
+function changeToAgent(agentName, clientId) {
+    return changeToAgentInternal(agentName, clientId);
+}
 
 const METHOD_NAME$11 = "function.template.navigateToAgent";
 /**
@@ -18443,6 +18539,21 @@ const createNavigateToAgent = ({ executeMessage = DEFAULT_EXECUTE_MESSAGE, emitM
 };
 
 const METHOD_NAME$10 = "function.setup.addTool";
+/**
+ * Function implementation
+ */
+const addToolInternal = 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$10, {
+            toolSchema,
+        });
+    // Register the tool in the validation and schema services
+    swarm$1.toolValidationService.addTool(toolSchema.toolName, toolSchema);
+    swarm$1.toolSchemaService.register(toolSchema.toolName, toolSchema);
+    // Return the tool's name as confirmation of registration
+    return toolSchema.toolName;
+});
 /**
  * Adds a new tool to the tool registry for use by agents in the swarm system.
  *
@@ -18461,18 +18572,9 @@ const METHOD_NAME$10 = "function.setup.addTool";
  * const toolName = addTool(toolSchema);
  * console.log(toolName); // Outputs "Calculator"
  */
-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$10, {
-            toolSchema,
-        });
-    // Register the tool in the validation and schema services
-    swarm$1.toolValidationService.addTool(toolSchema.toolName, toolSchema);
-    swarm$1.toolSchemaService.register(toolSchema.toolName, toolSchema);
-    // Return the tool's name as confirmation of registration
-    return toolSchema.toolName;
-});
+function addTool(toolSchema) {
+    return addToolInternal(toolSchema);
+}
 
 /**
  * Adds navigation functionality to an agent by creating a tool that allows navigation to a specified agent.
@@ -18481,17 +18583,9 @@ const addTool = beginContext((toolSchema) => {
 const METHOD_NAME$$ = "function.alias.addAgentNavigation";
 const DEFAULT_SKIP_PLACEHOLDER$1 = "Navigation canceled";
 /**
- * Creates and registers a navigation tool for an agent to navigate to another specified agent.
- * @function addAgentNavigation
- * @param {IAgentNavigationParams} params - The parameters for configuring the navigation tool.
- * @param {ToolName} params.toolName - The name of the tool.
- * @param {string} params.description - Description of the tool's purpose.
- * @param {AgentName} params.navigateTo - The target agent to navigate to.
- * @param {string} [params.docNote] - Optional documentation note.
- * @param {...INavigateToAgentParams} params.navigateProps - Additional navigation properties.
- * @returns {ReturnType<typeof addTool>} The result of adding the navigation tool.
+ * Function implementation
  */
-const addAgentNavigation = beginContext(({ toolName, docNote, description, navigateTo, skipPlaceholder = DEFAULT_SKIP_PLACEHOLDER$1, ...navigateProps }) => {
+const addAgentNavigationInternal = beginContext(({ toolName, docNote, description, navigateTo, skipPlaceholder = DEFAULT_SKIP_PLACEHOLDER$1, ...navigateProps }) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$$);
     const navigate = createNavigateToAgent(navigateProps);
     return addTool({
@@ -18516,6 +18610,20 @@ const addAgentNavigation = beginContext(({ toolName, docNote, description, navig
         },
     });
 });
+/**
+ * Creates and registers a navigation tool for an agent to navigate to another specified agent.
+ * @function addAgentNavigation
+ * @param {IAgentNavigationParams} params - The parameters for configuring the navigation tool.
+ * @param {ToolName} params.toolName - The name of the tool.
+ * @param {string} params.description - Description of the tool's purpose.
+ * @param {AgentName} params.navigateTo - The target agent to navigate to.
+ * @param {string} [params.docNote] - Optional documentation note.
+ * @param {...INavigateToAgentParams} params.navigateProps - Additional navigation properties.
+ * @returns {ReturnType<typeof addTool>} The result of adding the navigation tool.
+ */
+function addAgentNavigation(params) {
+    return addAgentNavigationInternal(params);
+}
 
 /**
  * Adds triage navigation functionality to an agent by creating a tool that facilitates navigation to a triage agent.
@@ -18524,16 +18632,9 @@ const addAgentNavigation = beginContext(({ toolName, docNote, description, navig
 const METHOD_NAME$_ = "function.alias.addTriageNavigation";
 const DEFAULT_SKIP_PLACEHOLDER = "Navigation canceled";
 /**
- * Creates and registers a triage navigation tool for an agent to navigate to a triage agent.
- * @function addTriageNavigation
- * @param {ITriageNavigationParams} params - The parameters for configuring the triage navigation tool.
- * @param {ToolName} params.toolName - The name of the tool.
- * @param {string} params.description - Description of the tool's purpose.
- * @param {string} [params.docNote] - Optional documentation note.
- * @param {...INavigateToTriageParams} params.navigateProps - Additional triage navigation properties.
- * @returns {ReturnType<typeof addTool>} The result of adding the triage navigation tool.
+ * Function implementation
  */
-const addTriageNavigation = beginContext(({ toolName, docNote, description, skipPlaceholder = DEFAULT_SKIP_PLACEHOLDER, ...navigateProps }) => {
+const addTriageNavigationInternal = beginContext(({ toolName, docNote, description, skipPlaceholder = DEFAULT_SKIP_PLACEHOLDER, ...navigateProps }) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$_);
     const navigate = createNavigateToTriageAgent(navigateProps);
     return addTool({
@@ -18558,16 +18659,26 @@ const addTriageNavigation = beginContext(({ toolName, docNote, description, skip
         },
     });
 });
+/**
+ * Creates and registers a triage navigation tool for an agent to navigate to a triage agent.
+ * @function addTriageNavigation
+ * @param {ITriageNavigationParams} params - The parameters for configuring the triage navigation tool.
+ * @param {ToolName} params.toolName - The name of the tool.
+ * @param {string} params.description - Description of the tool's purpose.
+ * @param {string} [params.docNote] - Optional documentation note.
+ * @param {...INavigateToTriageParams} params.navigateProps - Additional triage navigation properties.
+ * @returns {ReturnType<typeof addTool>} The result of adding the triage navigation tool.
+ */
+function addTriageNavigation(params) {
+    return addTriageNavigationInternal(params);
+}
 
 /** @constant {string} METHOD_NAME - The name of the method used for logging */
 const METHOD_NAME$Z = "function.setup.addWiki";
 /**
- * Adds a wiki schema to the system
- * @function addWiki
- * @param {IWikiSchema} wikiSchema - The wiki schema to add
- * @returns {string} The name of the added wiki
+ * Function implementation
  */
-const addWiki = beginContext((wikiSchema) => {
+const addWikiInternal = beginContext((wikiSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
         swarm$1.loggerService.log(METHOD_NAME$Z, {
             wikiSchema,
@@ -18576,8 +18687,32 @@ const addWiki = beginContext((wikiSchema) => {
     swarm$1.wikiSchemaService.register(wikiSchema.wikiName, wikiSchema);
     return wikiSchema.wikiName;
 });
+/**
+ * Adds a wiki schema to the system
+ * @function addWiki
+ * @param {IWikiSchema} wikiSchema - The wiki schema to add
+ * @returns {string} The name of the added wiki
+ */
+function addWiki(wikiSchema) {
+    return addWikiInternal(wikiSchema);
+}
 
 const METHOD_NAME$Y = "function.setup.addAgent";
+/**
+ * Function implementation
+ */
+const addAgentInternal = 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$Y, {
+            agentSchema,
+        });
+    // Register the agent in the validation and schema services
+    swarm$1.agentValidationService.addAgent(agentSchema.agentName, agentSchema);
+    swarm$1.agentSchemaService.register(agentSchema.agentName, agentSchema);
+    // Return the agent's name as confirmation of registration
+    return agentSchema.agentName;
+});
 /**
  * Adds a new agent to the agent registry for use within the swarm system.
  *
@@ -18594,22 +18729,28 @@ const METHOD_NAME$Y = "function.setup.addAgent";
  * const agentName = addAgent(agentSchema);
  * console.log(agentName); // Outputs "AgentX"
  */
-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$Y, {
-            agentSchema,
-        });
-    // Register the agent in the validation and schema services
-    swarm$1.agentValidationService.addAgent(agentSchema.agentName, agentSchema);
-    swarm$1.agentSchemaService.register(agentSchema.agentName, agentSchema);
-    // Return the agent's name as confirmation of registration
-    return agentSchema.agentName;
-});
+function addAgent(agentSchema) {
+    return addAgentInternal(agentSchema);
+}
 
 const METHOD_NAME$X = "function.setup.addCompletion";
 /**
- * Adds a completion engine to the registry for use by agents in the swarm system.
+ * Function implementation
+ */
+const addCompletionInternal = 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$X, {
+            completionSchema,
+        });
+    // Register the completion in the validation and schema services
+    swarm$1.completionValidationService.addCompletion(completionSchema.completionName);
+    swarm$1.completionSchemaService.register(completionSchema.completionName, completionSchema);
+    // Return the completion's name as confirmation of registration
+    return completionSchema.completionName;
+});
+/**
+ * Adds a completion engine to the registry for use by agents in the swarm system.
  *
  * This function registers a completion engine, enabling agents to utilize various models and frameworks (e.g., mock, GPT4All, Ollama, OpenAI)
  * for generating completions. The completion schema is added to the validation and schema services, making it available for agent operations.
@@ -18624,20 +18765,26 @@ const METHOD_NAME$X = "function.setup.addCompletion";
  * const completionName = addCompletion(completionSchema);
  * console.log(completionName); // Outputs "OpenAI"
  */
-const addCompletion = beginContext((completionSchema) => {
+function addCompletion(completionSchema) {
+    return addCompletionInternal(completionSchema);
+}
+
+const METHOD_NAME$W = "function.setup.addSwarm";
+/**
+ * Function implementation
+ */
+const addSwarmInternal = 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$X, {
-            completionSchema,
+        swarm$1.loggerService.log(METHOD_NAME$W, {
+            swarmSchema,
         });
-    // Register the completion in the validation and schema services
-    swarm$1.completionValidationService.addCompletion(completionSchema.completionName);
-    swarm$1.completionSchemaService.register(completionSchema.completionName, completionSchema);
-    // Return the completion's name as confirmation of registration
-    return completionSchema.completionName;
+    // Register the swarm in the validation and schema services
+    swarm$1.swarmValidationService.addSwarm(swarmSchema.swarmName, swarmSchema);
+    swarm$1.swarmSchemaService.register(swarmSchema.swarmName, swarmSchema);
+    // Return the swarm's name as confirmation of registration
+    return swarmSchema.swarmName;
 });
-
-const METHOD_NAME$W = "function.setup.addSwarm";
 /**
  * Adds a new swarm to the system for managing client sessions.
  *
@@ -18654,26 +18801,15 @@ const METHOD_NAME$W = "function.setup.addSwarm";
  * const swarmName = addSwarm(swarmSchema);
  * console.log(swarmName); // Outputs "TaskSwarm"
  */
-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$W, {
-            swarmSchema,
-        });
-    // Register the swarm in the validation and schema services
-    swarm$1.swarmValidationService.addSwarm(swarmSchema.swarmName, swarmSchema);
-    swarm$1.swarmSchemaService.register(swarmSchema.swarmName, swarmSchema);
-    // Return the swarm's name as confirmation of registration
-    return swarmSchema.swarmName;
-});
+function addSwarm(swarmSchema) {
+    return addSwarmInternal(swarmSchema);
+}
 
 const METHOD_NAME$V = "function.setup.addMCP";
 /**
- * Registers a new MCP (Model Context Protocol) schema in the system.
- * @param mcpSchema - The MCP schema to register.
- * @returns The name of the registered MCP.
+ * Function implementation
  */
-const addMCP = beginContext((mcpSchema) => {
+const addMCPInternal = beginContext((mcpSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
         swarm$1.loggerService.log(METHOD_NAME$V, {
             mcpSchema,
@@ -18682,27 +18818,20 @@ const addMCP = beginContext((mcpSchema) => {
     swarm$1.mcpSchemaService.register(mcpSchema.mcpName, mcpSchema);
     return mcpSchema.mcpName;
 });
+/**
+ * Registers a new MCP (Model Context Protocol) schema in the system.
+ * @param mcpSchema - The MCP schema to register.
+ * @returns The name of the registered MCP.
+ */
+function addMCP(mcpSchema) {
+    return addMCPInternal(mcpSchema);
+}
 
 const METHOD_NAME$U = "function.setup.addState";
 /**
- * Adds a new state to the state registry for use within the swarm system.
- *
- * This function registers a new state, enabling the swarm to manage and utilize it for agent operations or shared data persistence.
- * Only states registered through this function are recognized by the swarm. If the state is marked as shared, it initializes a connection
- * to the shared state service and waits for its initialization. The execution is wrapped in `beginContext` to ensure it runs outside of
- * existing method and execution contexts, providing a clean execution environment. The function logs the operation if enabled and returns
- * the state's name upon successful registration.
- *
- * @template T - The type of data stored in the state (defaults to `any` if unspecified).
- * @param {IStateSchema<T>} stateSchema - The schema defining the state's properties, including its name (`stateName`), shared status (`shared`), and other configuration details.
- * @returns {string} The name of the newly added state (`stateSchema.stateName`), confirming its registration.
- * @throws {Error} If the state schema is invalid, registration fails (e.g., duplicate state name), or shared state initialization encounters an error.
- * @example
- * const stateSchema = { stateName: "UserPrefs", shared: true, initialValue: { theme: "dark" } };
- * const stateName = addState(stateSchema);
- * console.log(stateName); // Outputs "UserPrefs"
+ * Function implementation
  */
-const addState = beginContext((stateSchema) => {
+const addStateInternal = 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$U, {
@@ -18721,8 +18850,44 @@ const addState = beginContext((stateSchema) => {
     // Return the state's name as confirmation of registration
     return stateSchema.stateName;
 });
+/**
+ * Adds a new state to the state registry for use within the swarm system.
+ *
+ * This function registers a new state, enabling the swarm to manage and utilize it for agent operations or shared data persistence.
+ * Only states registered through this function are recognized by the swarm. If the state is marked as shared, it initializes a connection
+ * to the shared state service and waits for its initialization. The execution is wrapped in `beginContext` to ensure it runs outside of
+ * existing method and execution contexts, providing a clean execution environment. The function logs the operation if enabled and returns
+ * the state's name upon successful registration.
+ *
+ * @template T - The type of data stored in the state (defaults to `any` if unspecified).
+ * @param {IStateSchema<T>} stateSchema - The schema defining the state's properties, including its name (`stateName`), shared status (`shared`), and other configuration details.
+ * @returns {string} The name of the newly added state (`stateSchema.stateName`), confirming its registration.
+ * @throws {Error} If the state schema is invalid, registration fails (e.g., duplicate state name), or shared state initialization encounters an error.
+ * @example
+ * const stateSchema = { stateName: "UserPrefs", shared: true, initialValue: { theme: "dark" } };
+ * const stateName = addState(stateSchema);
+ * console.log(stateName); // Outputs "UserPrefs"
+ */
+function addState(stateSchema) {
+    return addStateInternal(stateSchema);
+}
 
 const METHOD_NAME$T = "function.setup.addEmbedding";
+/**
+ * Function implementation
+ */
+const addEmbeddingInternal = 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$T, {
+            embeddingSchema,
+        });
+    // Register the embedding in the validation and schema services
+    swarm$1.embeddingValidationService.addEmbedding(embeddingSchema.embeddingName, embeddingSchema);
+    swarm$1.embeddingSchemaService.register(embeddingSchema.embeddingName, embeddingSchema);
+    // Return the embedding's name as confirmation of registration
+    return embeddingSchema.embeddingName;
+});
 /**
  * Adds a new embedding engine to the embedding registry for use within the swarm system.
  *
@@ -18739,20 +18904,32 @@ const METHOD_NAME$T = "function.setup.addEmbedding";
  * const embeddingName = addEmbedding(embeddingSchema);
  * console.log(embeddingName); // Outputs "TextEmbedder"
  */
-const addEmbedding = beginContext((embeddingSchema) => {
+function addEmbedding(embeddingSchema) {
+    return addEmbeddingInternal(embeddingSchema);
+}
+
+const METHOD_NAME$S = "function.setup.addStorage";
+/**
+ * Function implementation
+ */
+const addStorageInternal = 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$T, {
-            embeddingSchema,
+        swarm$1.loggerService.log(METHOD_NAME$S, {
+            storageSchema,
         });
-    // Register the embedding in the validation and schema services
-    swarm$1.embeddingValidationService.addEmbedding(embeddingSchema.embeddingName, embeddingSchema);
-    swarm$1.embeddingSchemaService.register(embeddingSchema.embeddingName, embeddingSchema);
-    // Return the embedding's name as confirmation of registration
-    return embeddingSchema.embeddingName;
+    // Register the storage in the validation and schema services
+    swarm$1.storageValidationService.addStorage(storageSchema.storageName, storageSchema);
+    swarm$1.storageSchemaService.register(storageSchema.storageName, storageSchema);
+    // If the storage is shared, initialize and wait for the shared storage connection
+    if (storageSchema.shared) {
+        swarm$1.sharedStorageConnectionService
+            .getStorage(storageSchema.storageName)
+            .waitForInit();
+    }
+    // Return the storage's name as confirmation of registration
+    return storageSchema.storageName;
 });
-
-const METHOD_NAME$S = "function.setup.addStorage";
 /**
  * Adds a new storage engine to the storage registry for use within the swarm system.
  *
@@ -18771,40 +18948,16 @@ const METHOD_NAME$S = "function.setup.addStorage";
  * const storageName = addStorage(storageSchema);
  * console.log(storageName); // Outputs "UserData"
  */
-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$S, {
-            storageSchema,
-        });
-    // Register the storage in the validation and schema services
-    swarm$1.storageValidationService.addStorage(storageSchema.storageName, storageSchema);
-    swarm$1.storageSchemaService.register(storageSchema.storageName, storageSchema);
-    // If the storage is shared, initialize and wait for the shared storage connection
-    if (storageSchema.shared) {
-        swarm$1.sharedStorageConnectionService
-            .getStorage(storageSchema.storageName)
-            .waitForInit();
-    }
-    // Return the storage's name as confirmation of registration
-    return storageSchema.storageName;
-});
+function addStorage(storageSchema) {
+    return addStorageInternal(storageSchema);
+}
 
 /** @private Constant defining the method name for logging and validation context */
 const METHOD_NAME$R = "function.setup.addPolicy";
 /**
- * Adds a new policy for agents in the swarm system by registering it with validation and schema services.
- * Registers the policy with PolicyValidationService for runtime validation and PolicySchemaService for schema management.
- * Runs within a beginContext wrapper for execution context management, logging operations via LoggerService.
- * Integrates with PolicyValidationService (policy registration and validation), PolicySchemaService (schema registration),
- * and LoggerService (logging). Part of the swarm setup process, enabling policies to govern agent behavior,
- * complementing runtime functions like commitAssistantMessage by defining operational rules upfront.
- *
- * @param {IPolicySchema} policySchema - The schema of the policy to be added, including policyName and other configuration details.
- * @returns {string} The name of the policy that was added, as specified in policySchema.policyName.
- * @throws {Error} If policy registration fails due to validation errors in PolicyValidationService or PolicySchemaService.
+ * Function implementation
  */
-const addPolicy = beginContext((policySchema) => {
+const addPolicyInternal = beginContext((policySchema) => {
     // Log the policy addition attempt if enabled
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
         swarm$1.loggerService.log(METHOD_NAME$R, {
@@ -18817,19 +18970,30 @@ const addPolicy = beginContext((policySchema) => {
     // Return the policy name as confirmation of successful addition
     return policySchema.policyName;
 });
+/**
+ * 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.
+ * Runs within a beginContext wrapper for execution context management, logging operations via LoggerService.
+ * Integrates with PolicyValidationService (policy registration and validation), PolicySchemaService (schema registration),
+ * and LoggerService (logging). Part of the swarm setup process, enabling policies to govern agent behavior,
+ * complementing runtime functions like commitAssistantMessage by defining operational rules upfront.
+ *
+ * @param {IPolicySchema} policySchema - The schema of the policy to be added, including policyName and other configuration details.
+ * @returns {string} The name of the policy that was added, as specified in policySchema.policyName.
+ * @throws {Error} If policy registration fails due to validation errors in PolicyValidationService or PolicySchemaService.
+ */
+function addPolicy(policySchema) {
+    return addPolicyInternal(policySchema);
+}
 
 /**
  * @module addCompute
  * @description Provides a function to register a compute schema with validation and logging.
  */
 /**
- * @function addCompute
- * @description Registers a compute schema, validates it, and adds it to the compute schema service.
- * @template T - Type extending IComputeData.
- * @param {IComputeSchema<T>} computeSchema - The compute schema to register.
- * @returns {string} The name of the registered compute.
+ * Function implementation
  */
-const addCompute = beginContext((computeSchema) => {
+const addComputeInternal = beginContext((computeSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
         swarm$1.loggerService.log("function.setup.addCompute", {
             computeSchema,
@@ -18838,6 +19002,15 @@ const addCompute = beginContext((computeSchema) => {
     swarm$1.computeSchemaService.register(computeSchema.computeName, computeSchema);
     return computeSchema.computeName;
 });
+/**
+ * Registers a compute schema, validates it, and adds it to the compute schema service.
+ * @template T - Type extending IComputeData.
+ * @param {IComputeSchema<T>} computeSchema - The compute schema to register.
+ * @returns {string} The name of the registered compute.
+ */
+function addCompute(computeSchema) {
+    return addComputeInternal(computeSchema);
+}
 
 /**
  * @module addPipeline
@@ -18850,13 +19023,9 @@ const addCompute = beginContext((computeSchema) => {
  */
 const METHOD_NAME$Q = "function.setup.addPipeline";
 /**
- * @function addPipeline
- * @description Registers a pipeline schema, validates it, and adds it to the pipeline schema service.
- * @template Payload - Type extending object for the pipeline payload.
- * @param {IPipelineSchema<Payload>} pipelineSchema - The pipeline schema to register.
- * @returns {string} The name of the registered pipeline.
+ * Function implementation
  */
-const addPipeline = beginContext((pipelineSchema) => {
+const addPipelineInternal = beginContext((pipelineSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
         swarm$1.loggerService.log(METHOD_NAME$Q, {
             pipelineSchema,
@@ -18865,8 +19034,28 @@ const addPipeline = beginContext((pipelineSchema) => {
     swarm$1.pipelineSchemaService.register(pipelineSchema.pipelineName, pipelineSchema);
     return pipelineSchema.pipelineName;
 });
+/**
+ * Registers a pipeline schema, validates it, and adds it to the pipeline schema service.
+ * @template Payload - Type extending object for the pipeline payload.
+ * @param {IPipelineSchema<Payload>} pipelineSchema - The pipeline schema to register.
+ * @returns {string} The name of the registered pipeline.
+ */
+function addPipeline(pipelineSchema) {
+    return addPipelineInternal(pipelineSchema);
+}
 
 const METHOD_NAME$P = "function.test.overrideAgent";
+/**
+ * Function implementation
+ */
+const overrideAgentInternal = beginContext((agentSchema) => {
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
+        swarm$1.loggerService.log(METHOD_NAME$P, {
+            agentSchema,
+        });
+    swarm$1.agentSchemaService.get(agentSchema.agentName);
+    return swarm$1.agentSchemaService.override(agentSchema.agentName, agentSchema);
+});
 /**
  * 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.
@@ -18888,16 +19077,21 @@ const METHOD_NAME$P = "function.test.overrideAgent";
  * });
  * // Logs the operation (if enabled) and updates the agent schema in the swarm.
  */
-const overrideAgent = beginContext((agentSchema) => {
+function overrideAgent(agentSchema) {
+    return overrideAgentInternal(agentSchema);
+}
+
+const METHOD_NAME$O = "function.test.overrideCompletion";
+/**
+ * Function implementation
+ */
+const overrideCompletionInternal = beginContext((completionSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$P, {
-            agentSchema,
+        swarm$1.loggerService.log(METHOD_NAME$O, {
+            completionSchema,
         });
-    swarm$1.agentSchemaService.get(agentSchema.agentName);
-    return swarm$1.agentSchemaService.override(agentSchema.agentName, agentSchema);
+    return swarm$1.completionSchemaService.override(completionSchema.completionName, completionSchema);
 });
-
-const METHOD_NAME$O = "function.test.overrideCompletion";
 /**
  * Overrides an existing completion schema in the swarm system with a new or partial schema.
  * This function updates the configuration of a completion mechanism identified by its `completionName`, applying the provided schema properties.
@@ -18919,15 +19113,21 @@ const METHOD_NAME$O = "function.test.overrideCompletion";
  * });
  * // Logs the operation (if enabled) and updates the completion schema in the swarm.
  */
-const overrideCompletion = beginContext((completionSchema) => {
+function overrideCompletion(completionSchema) {
+    return overrideCompletionInternal(completionSchema);
+}
+
+const METHOD_NAME$N = "function.test.overrideEmbeding";
+/**
+ * Function implementation
+ */
+const overrideEmbedingInternal = beginContext((embeddingSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$O, {
-            completionSchema,
+        swarm$1.loggerService.log(METHOD_NAME$N, {
+            embeddingSchema,
         });
-    return swarm$1.completionSchemaService.override(completionSchema.completionName, completionSchema);
+    return swarm$1.embeddingSchemaService.override(embeddingSchema.embeddingName, embeddingSchema);
 });
-
-const METHOD_NAME$N = "function.test.overrideEmbeding";
 /**
  * Overrides an existing embedding schema in the swarm system with a new or partial schema.
  * This function updates the configuration of an embedding mechanism identified by its `embeddingName`, applying the provided schema properties.
@@ -18951,15 +19151,21 @@ const METHOD_NAME$N = "function.test.overrideEmbeding";
  * });
  * // Logs the operation (if enabled) and updates the embedding schema in the swarm.
  */
-const overrideEmbeding = beginContext((embeddingSchema) => {
+function overrideEmbeding(embeddingSchema) {
+    return overrideEmbedingInternal(embeddingSchema);
+}
+
+const METHOD_NAME$M = "function.test.overridePolicy";
+/**
+ * Function implementation
+ */
+const overridePolicyInternal = beginContext((policySchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$N, {
-            embeddingSchema,
+        swarm$1.loggerService.log(METHOD_NAME$M, {
+            policySchema,
         });
-    return swarm$1.embeddingSchemaService.override(embeddingSchema.embeddingName, embeddingSchema);
+    return swarm$1.policySchemaService.override(policySchema.policyName, policySchema);
 });
-
-const METHOD_NAME$M = "function.test.overridePolicy";
 /**
  * Overrides an existing policy schema in the swarm system with a new or partial schema.
  * This function updates the configuration of a policy identified by its `policyName`, applying the provided schema properties.
@@ -18981,15 +19187,21 @@ const METHOD_NAME$M = "function.test.overridePolicy";
  * });
  * // Logs the operation (if enabled) and updates the policy schema in the swarm.
  */
-const overridePolicy = beginContext((policySchema) => {
+function overridePolicy(policySchema) {
+    return overridePolicyInternal(policySchema);
+}
+
+const METHOD_NAME$L = "function.test.overrideState";
+/**
+ * Function implementation
+ */
+const overrideStateInternal = beginContext((stateSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$M, {
-            policySchema,
+        swarm$1.loggerService.log(METHOD_NAME$L, {
+            stateSchema,
         });
-    return swarm$1.policySchemaService.override(policySchema.policyName, policySchema);
+    return swarm$1.stateSchemaService.override(stateSchema.stateName, stateSchema);
 });
-
-const METHOD_NAME$L = "function.test.overrideState";
 /**
  * Overrides an existing state schema in the swarm system with a new or partial schema.
  * This function updates the configuration of a state identified by its `stateName`, applying the provided schema properties.
@@ -19012,15 +19224,21 @@ const METHOD_NAME$L = "function.test.overrideState";
  * });
  * // Logs the operation (if enabled) and updates the state schema in the swarm.
  */
-const overrideState = beginContext((stateSchema) => {
-    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$L, {
-            stateSchema,
-        });
-    return swarm$1.stateSchemaService.override(stateSchema.stateName, stateSchema);
-});
+function overrideState(stateSchema) {
+    return overrideStateInternal(stateSchema);
+}
 
 const METHOD_NAME$K = "function.test.overrideStorage";
+/**
+ * Function implementation
+ */
+const overrideStorageInternal = beginContext((storageSchema) => {
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
+        swarm$1.loggerService.log(METHOD_NAME$K, {
+            storageSchema,
+        });
+    return swarm$1.storageSchemaService.override(storageSchema.storageName, storageSchema);
+});
 /**
  * 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.
@@ -19044,15 +19262,21 @@ const METHOD_NAME$K = "function.test.overrideStorage";
  * });
  * // Logs the operation (if enabled) and updates the storage schema in the swarm.
  */
-const overrideStorage = beginContext((storageSchema) => {
+function overrideStorage(storageSchema) {
+    return overrideStorageInternal(storageSchema);
+}
+
+const METHOD_NAME$J = "function.test.overrideSwarm";
+/**
+ * Function implementation
+ */
+const overrideSwarmInternal = beginContext((swarmSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$K, {
-            storageSchema,
+        swarm$1.loggerService.log(METHOD_NAME$J, {
+            swarmSchema,
         });
-    return swarm$1.storageSchemaService.override(storageSchema.storageName, storageSchema);
+    return swarm$1.swarmSchemaService.override(swarmSchema.swarmName, swarmSchema);
 });
-
-const METHOD_NAME$J = "function.test.overrideSwarm";
 /**
  * Overrides an existing swarm schema in the swarm system with a new or partial schema.
  * This function updates the configuration of a swarm identified by its `swarmName`, applying the provided schema properties.
@@ -19074,15 +19298,21 @@ const METHOD_NAME$J = "function.test.overrideSwarm";
  * });
  * // Logs the operation (if enabled) and updates the swarm schema in the swarm system.
  */
-const overrideSwarm = beginContext((swarmSchema) => {
+function overrideSwarm(swarmSchema) {
+    return overrideSwarmInternal(swarmSchema);
+}
+
+const METHOD_NAME$I = "function.test.overrideTool";
+/**
+ * Function implementation
+ */
+const overrideToolInternal = beginContext((toolSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$J, {
-            swarmSchema,
+        swarm$1.loggerService.log(METHOD_NAME$I, {
+            toolSchema,
         });
-    return swarm$1.swarmSchemaService.override(swarmSchema.swarmName, swarmSchema);
+    return swarm$1.toolSchemaService.override(toolSchema.toolName, toolSchema);
 });
-
-const METHOD_NAME$I = "function.test.overrideTool";
 /**
  * Overrides an existing tool schema in the swarm system with a new or partial schema.
  * This function updates the configuration of a tool identified by its `toolName`, applying the provided schema properties.
@@ -19104,29 +19334,41 @@ const METHOD_NAME$I = "function.test.overrideTool";
  * });
  * // Logs the operation (if enabled) and updates the tool schema in the swarm.
  */
-const overrideTool = beginContext((toolSchema) => {
-    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$I, {
-            toolSchema,
-        });
-    return swarm$1.toolSchemaService.override(toolSchema.toolName, toolSchema);
-});
+function overrideTool(toolSchema) {
+    return overrideToolInternal(toolSchema);
+}
 
 const METHOD_NAME$H = "function.test.overrideMCP";
 /**
- * Overrides an existing MCP (Model Context Protocol) schema with a new or partial schema.
- * @param mcpSchema - The MCP schema containing the name and optional properties to override.
- * @returns The result of the override operation from the MCP schema service.
+ * Function implementation
  */
-const overrideMCP = beginContext((mcpSchema) => {
+const overrideMCPInternal = beginContext((mcpSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
         swarm$1.loggerService.log(METHOD_NAME$H, {
             mcpSchema,
         });
     return swarm$1.mcpSchemaService.override(mcpSchema.mcpName, mcpSchema);
 });
+/**
+ * Overrides an existing MCP (Model Context Protocol) schema with a new or partial schema.
+ * @param mcpSchema - The MCP schema containing the name and optional properties to override.
+ * @returns The result of the override operation from the MCP schema service.
+ */
+function overrideMCP(mcpSchema) {
+    return overrideMCPInternal(mcpSchema);
+}
 
 const METHOD_NAME$G = "function.test.overrideWiki";
+/**
+ * Function implementation
+ */
+const overrideWikiInternal = beginContext((wikiSchema) => {
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
+        swarm$1.loggerService.log(METHOD_NAME$G, {
+            wikiSchema,
+        });
+    return swarm$1.wikiSchemaService.override(wikiSchema.wikiName, wikiSchema);
+});
 /**
  * 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.
@@ -19148,13 +19390,9 @@ const METHOD_NAME$G = "function.test.overrideWiki";
  * });
  * // Logs the operation (if enabled) and updates the wiki schema in the swarm.
  */
-const overrideWiki = beginContext((wikiSchema) => {
-    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$G, {
-            wikiSchema,
-        });
-    return swarm$1.wikiSchemaService.override(wikiSchema.wikiName, wikiSchema);
-});
+function overrideWiki(wikiSchema) {
+    return overrideWikiInternal(wikiSchema);
+}
 
 /**
  * @module overrideCompute
@@ -19167,18 +19405,23 @@ const overrideWiki = beginContext((wikiSchema) => {
  */
 const METHOD_NAME$F = "function.test.overrideCompute";
 /**
- * @function overrideCompute
- * @description Overrides an existing compute schema with provided partial updates.
- * @param {TComputeSchema} computeSchema - The partial compute schema with updates.
- * @returns {IComputeSchema} The updated compute schema.
+ * Function implementation
  */
-const overrideCompute = beginContext((computeSchema) => {
+const overrideComputeInternal = beginContext((computeSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
         swarm$1.loggerService.log(METHOD_NAME$F, {
             computeSchema,
         });
     return swarm$1.computeSchemaService.override(computeSchema.computeName, computeSchema);
 });
+/**
+ * Overrides an existing compute schema with provided partial updates.
+ * @param {TComputeSchema} computeSchema - The partial compute schema with updates.
+ * @returns {IComputeSchema} The updated compute schema.
+ */
+function overrideCompute(computeSchema) {
+    return overrideComputeInternal(computeSchema);
+}
 
 /**
  * @module overridePipeline
@@ -19191,30 +19434,30 @@ const overrideCompute = beginContext((computeSchema) => {
  */
 const METHOD_NAME$E = "function.test.overridePipeline";
 /**
- * @function overridePipeline
- * @description Overrides an existing pipeline schema with provided partial updates.
- * @template Payload - Type extending object for the pipeline payload.
- * @param {IPipelineSchema<Payload>} pipelineSchema - The partial pipeline schema with updates.
- * @returns {IPipelineSchema<Payload>} The updated pipeline schema.
+ * Function implementation
  */
-const overridePipeline = beginContext((pipelineSchema) => {
+const overridePipelineInternal = beginContext((pipelineSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
         swarm$1.loggerService.log(METHOD_NAME$E, {
             pipelineSchema,
         });
     return swarm$1.pipelineSchemaService.override(pipelineSchema.pipelineName, pipelineSchema);
 });
+/**
+ * Overrides an existing pipeline schema with provided partial updates.
+ * @template Payload - Type extending object for the pipeline payload.
+ * @param {IPipelineSchema<Payload>} pipelineSchema - The partial pipeline schema with updates.
+ * @returns {IPipelineSchema<Payload>} The updated pipeline schema.
+ */
+function overridePipeline(pipelineSchema) {
+    return overridePipelineInternal(pipelineSchema);
+}
 
 const METHOD_NAME$D = "function.other.markOnline";
 /**
- * Marks a client as online in the specified swarm.
- *
- * @param {string} clientId - The unique identifier of the client to mark as online.
- * @param {SwarmName} swarmName - The name of the swarm where the client is being marked online.
- * @returns {Promise<void>} A promise that resolves when the client is successfully marked online.
- * @throws {Error} Throws an error if the swarm validation fails or if the operation fails.
+ * Function implementation
  */
-const markOnline = async (clientId, swarmName) => {
+const markOnlineInternal = 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$D, {
@@ -19237,21 +19480,23 @@ const markOnline = async (clientId, swarmName) => {
         clientId,
     });
 };
+/**
+ * Marks a client as online in the specified swarm.
+ *
+ * @param {string} clientId - The unique identifier of the client to mark as online.
+ * @param {SwarmName} swarmName - The name of the swarm where the client is being marked online.
+ * @returns {Promise<void>} A promise that resolves when the client is successfully marked online.
+ * @throws {Error} Throws an error if the swarm validation fails or if the operation fails.
+ */
+function markOnline(clientId, swarmName) {
+    return markOnlineInternal(clientId, swarmName);
+}
 
 const METHOD_NAME$C = "function.other.markOffline";
 /**
- * Marks a client as offline in the specified swarm.
- *
- * @param {string} clientId - The unique identifier of the client to mark as offline.
- * @param {SwarmName} swarmName - The name of the swarm where the client belongs.
- * @returns {Promise<void>} A promise that resolves when the client is successfully marked as offline.
- *
- * @throws {Error} If the swarm validation fails or the operation encounters an issue.
- *
- * @example
- * await markOffline("client123", "exampleSwarm");
+ * Function implementation
  */
-const markOffline = async (clientId, swarmName) => {
+const markOfflineInternal = async (clientId, swarmName) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
         swarm.loggerService.log(METHOD_NAME$C, {
             clientId,
@@ -19271,25 +19516,28 @@ const markOffline = async (clientId, swarmName) => {
         clientId,
     });
 };
+/**
+ * Marks a client as offline in the specified swarm.
+ *
+ * @param {string} clientId - The unique identifier of the client to mark as offline.
+ * @param {SwarmName} swarmName - The name of the swarm where the client belongs.
+ * @returns {Promise<void>} A promise that resolves when the client is successfully marked as offline.
+ *
+ * @throws {Error} If the swarm validation fails or the operation encounters an issue.
+ *
+ * @example
+ * await markOffline("client123", "exampleSwarm");
+ */
+function markOffline(clientId, swarmName) {
+    return markOfflineInternal(clientId, swarmName);
+}
 
 /** @private Constant defining the method name for logging and validation context */
 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.
- * Runs within a beginContext wrapper for execution context management, logging operations via LoggerService.
- * Integrates with AgentValidationService (agent validation), SessionValidationService (session and swarm retrieval),
- * SwarmValidationService (swarm validation), SwarmPublicService (agent retrieval), SessionPublicService (message committing),
- * and LoggerService (logging). Complements functions like commitAssistantMessage by handling system messages (e.g., configuration or control messages)
- * rather than assistant-generated responses.
- *
- * @param {string} content - The content of the system message to commit, typically related to system state or control instructions.
- * @param {string} clientId - The ID of the client associated with the session, validated against active sessions.
- * @param {string} agentName - The name of the agent to commit the message for, validated against registered agents.
- * @returns {Promise<void>} A promise that resolves when the message is committed or skipped (e.g., agent mismatch).
- * @throws {Error} If agent, session, or swarm validation fails, propagated from respective validation services.
+ * Function implementation
  */
-const commitSystemMessage = beginContext(async (content, clientId, agentName) => {
+const commitSystemMessageInternal = beginContext(async (content, clientId, agentName) => {
     // Log the commit attempt if enabled
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
         swarm$1.loggerService.log(METHOD_NAME$B, {
@@ -19318,24 +19566,30 @@ const commitSystemMessage = beginContext(async (content, clientId, agentName) =>
     // Commit the system message via SessionPublicService
     await swarm$1.sessionPublicService.commitSystemMessage(content, METHOD_NAME$B, clientId, swarmName);
 });
+/**
+ * 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.
+ * Runs within a beginContext wrapper for execution context management, logging operations via LoggerService.
+ * Integrates with AgentValidationService (agent validation), SessionValidationService (session and swarm retrieval),
+ * SwarmValidationService (swarm validation), SwarmPublicService (agent retrieval), SessionPublicService (message committing),
+ * and LoggerService (logging). Complements functions like commitAssistantMessage by handling system messages (e.g., configuration or control messages)
+ * rather than assistant-generated responses.
+ *
+ * @param {string} content - The content of the system message to commit, typically related to system state or control instructions.
+ * @param {string} clientId - The ID of the client associated with the session, validated against active sessions.
+ * @param {string} agentName - The name of the agent to commit the message for, validated against registered agents.
+ * @returns {Promise<void>} A promise that resolves when the message is committed or skipped (e.g., agent mismatch).
+ * @throws {Error} If agent, session, or swarm validation fails, propagated from respective validation services.
+ */
+function commitSystemMessage(content, clientId, agentName) {
+    return commitSystemMessageInternal(content, clientId, agentName);
+}
 
 const METHOD_NAME$A = "function.commit.commitSystemMessage";
 /**
- * Commits a user message to the active agent's history in a swarm session without triggering a response.
- *
- * This function commits a user message to the history of the specified agent, ensuring the agent is still active in the swarm session.
- * It performs validation checks on the agent, 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} content - The content of the user message to be committed.
- * @param {string} clientId - The unique identifier of the client session associated with the operation.
- * @param {string} agentName - The name of the agent to whose history the message will be committed.
- * @returns {Promise<void>} A promise that resolves when the message is successfully committed, or immediately if the operation is skipped due to an agent change.
- * @throws {Error} If validation fails (e.g., invalid agent, session, or swarm) or if the session public service encounters an error during the commit operation.
- * @example
- * await commitUserMessage("User input message", "client-123", "AgentX");
+ * Function implementation
  */
-const commitUserMessage = beginContext(async (content, mode, clientId, agentName, payload) => {
+const commitUserMessageInternal = 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$A, {
@@ -19372,25 +19626,31 @@ const commitUserMessage = beginContext(async (content, mode, clientId, agentName
     // Commit the user message to the agent's history via the session public service
     return await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$A, clientId, swarmName);
 });
+/**
+ * Commits a user message to the active agent's history in a swarm session without triggering a response.
+ *
+ * This function commits a user message to the history of the specified agent, ensuring the agent is still active in the swarm session.
+ * It performs validation checks on the agent, 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} content - The content of the user message to be committed.
+ * @param {string} clientId - The unique identifier of the client session associated with the operation.
+ * @param {string} agentName - The name of the agent to whose history the message will be committed.
+ * @returns {Promise<void>} A promise that resolves when the message is successfully committed, or immediately if the operation is skipped due to an agent change.
+ * @throws {Error} If validation fails (e.g., invalid agent, session, or swarm) or if the session public service encounters an error during the commit operation.
+ * @example
+ * await commitUserMessage("User input message", "client-123", "AgentX");
+ */
+function commitUserMessage(content, mode, clientId, agentName, payload) {
+    return commitUserMessageInternal(content, mode, clientId, agentName, payload);
+}
 
 /** @private Constant defining the method name for logging and validation context */
 const METHOD_NAME$z = "function.commit.commitSystemMessageForce";
 /**
- * Forcefully commits a system-generated message to a session in the swarm system, without checking the active agent.
- * Validates the session and swarm, then proceeds with committing the message regardless of the current agent state.
- * Runs within a beginContext wrapper for execution context management, logging operations via LoggerService.
- * Integrates with SessionValidationService (session and swarm retrieval), SwarmValidationService (swarm validation),
- * SessionPublicService (message committing), and LoggerService (logging).
- * Unlike commitSystemMessage, this function skips agent validation and active agent checks, providing a more aggressive commit mechanism,
- * analogous to commitAssistantMessageForce vs. commitAssistantMessage.
- *
- * @param {string} content - The content of the system message to commit, typically related to system state or control instructions.
- * @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 commitSystemMessage).
- * @returns {Promise<void>} A promise that resolves when the message is committed.
- * @throws {Error} If session or swarm validation fails, propagated from respective validation services.
+ * Function implementation
  */
-const commitSystemMessageForce = beginContext(async (content, clientId) => {
+const commitSystemMessageForceInternal = beginContext(async (content, clientId) => {
     // Log the commit attempt if enabled
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
         swarm$1.loggerService.log(METHOD_NAME$z, {
@@ -19405,23 +19665,30 @@ const commitSystemMessageForce = beginContext(async (content, clientId) => {
     // Commit the system message via SessionPublicService without agent checks
     await swarm$1.sessionPublicService.commitSystemMessage(content, METHOD_NAME$z, clientId, swarmName);
 });
+/**
+ * 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.
+ * Runs within a beginContext wrapper for execution context management, logging operations via LoggerService.
+ * Integrates with SessionValidationService (session and swarm retrieval), SwarmValidationService (swarm validation),
+ * SessionPublicService (message committing), and LoggerService (logging).
+ * Unlike commitSystemMessage, this function skips agent validation and active agent checks, providing a more aggressive commit mechanism,
+ * analogous to commitAssistantMessageForce vs. commitAssistantMessage.
+ *
+ * @param {string} content - The content of the system message to commit, typically related to system state or control instructions.
+ * @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 commitSystemMessage).
+ * @returns {Promise<void>} A promise that resolves when the message is committed.
+ * @throws {Error} If session or swarm validation fails, propagated from respective validation services.
+ */
+function commitSystemMessageForce(content, clientId) {
+    return commitSystemMessageForceInternal(content, clientId);
+}
 
 const METHOD_NAME$y = "function.commit.commitSystemMessage";
 /**
- * Commits a user message to the active agent's history in a swarm session without triggering a response and without checking the active agent.
- *
- * This function forcefully commits a user message to the history of the active agent in the specified swarm session, bypassing the check for whether the agent is still active.
- * 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} content - The content of the user message 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 message 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 commitUserMessageForce("User input message", "client-123");
+ * Function implementation
  */
-const commitUserMessageForce = beginContext(async (content, mode, clientId, payload) => {
+const commitUserMessageForceInternal = 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$y, {
@@ -19444,24 +19711,30 @@ const commitUserMessageForce = beginContext(async (content, mode, clientId, payl
     // 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$y, clientId, swarmName);
 });
+/**
+ * Commits a user message to the active agent's history in a swarm session without triggering a response and without checking the active agent.
+ *
+ * This function forcefully commits a user message to the history of the active agent in the specified swarm session, bypassing the check for whether the agent is still active.
+ * 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} content - The content of the user message 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 message 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 commitUserMessageForce("User input message", "client-123");
+ */
+function commitUserMessageForce(content, mode, clientId, payload) {
+    return commitUserMessageForceInternal(content, mode, clientId, payload);
+}
 
 /** @private Constant defining the method name for logging and validation context */
 const METHOD_NAME$x = "function.commit.commitAssistantMessage";
 /**
- * Commits an assistant-generated message to the active agent in the swarm system.
- * Validates the agent, session, and swarm, ensuring the current agent matches the provided agent before committing the message.
- * Runs within a beginContext wrapper for execution context management, logging operations via LoggerService.
- * Integrates with AgentValidationService (agent validation), SessionValidationService (session and swarm retrieval),
- * SwarmValidationService (swarm validation), SwarmPublicService (agent retrieval), SessionPublicService (message committing),
- * and LoggerService (logging). Complements functions like cancelOutput by persisting assistant messages rather than canceling output.
- *
- * @param {string} content - The content of the assistant message to commit, typically generated by the agent.
- * @param {string} clientId - The ID of the client associated with the session, validated against active sessions.
- * @param {string} agentName - The name of the agent to commit the message for, validated against registered agents.
- * @returns {Promise<void>} A promise that resolves when the message is committed or skipped (e.g., agent mismatch).
- * @throws {Error} If agent, session, or swarm validation fails, propagated from respective validation services.
+ * Function implementation
  */
-const commitAssistantMessage = beginContext(async (content, clientId, agentName) => {
+const commitAssistantMessageInternal = beginContext(async (content, clientId, agentName) => {
     // Log the commit attempt if enabled
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
         swarm$1.loggerService.log(METHOD_NAME$x, {
@@ -19490,25 +19763,30 @@ const commitAssistantMessage = beginContext(async (content, clientId, agentName)
     // Commit the assistant message via SessionPublicService
     await swarm$1.sessionPublicService.commitAssistantMessage(content, METHOD_NAME$x, clientId, swarmName);
 });
-
-/** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$w = "function.commit.commitAssistantMessageForce";
 /**
- * Forcefully commits an assistant-generated message to a session in the swarm system, without checking the active agent.
- * Validates the session and swarm, then proceeds with committing the message regardless of the current agent state.
+ * 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.
  * Runs within a beginContext wrapper for execution context management, logging operations via LoggerService.
- * Integrates with SessionValidationService (session and swarm retrieval), SwarmValidationService (swarm validation),
- * SessionPublicService (message committing), and LoggerService (logging).
- * Unlike commitAssistantMessage, this function skips agent validation and active agent checks, providing a more aggressive commit mechanism,
- * analogous to cancelOutputForce vs. cancelOutput.
+ * Integrates with AgentValidationService (agent validation), SessionValidationService (session and swarm retrieval),
+ * SwarmValidationService (swarm validation), SwarmPublicService (agent retrieval), SessionPublicService (message committing),
+ * and LoggerService (logging). Complements functions like cancelOutput by persisting assistant messages rather than canceling output.
  *
- * @param {string} content - The content of the assistant message to commit, typically generated by an agent.
+ * @param {string} content - The content of the assistant message to commit, typically generated by the agent.
  * @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 commitAssistantMessage).
- * @returns {Promise<void>} A promise that resolves when the message is committed.
- * @throws {Error} If session or swarm validation fails, propagated from respective validation services.
+ * @param {string} agentName - The name of the agent to commit the message for, validated against registered agents.
+ * @returns {Promise<void>} A promise that resolves when the message is committed or skipped (e.g., agent mismatch).
+ * @throws {Error} If agent, session, or swarm validation fails, propagated from respective validation services.
  */
-const commitAssistantMessageForce = beginContext(async (content, clientId) => {
+function commitAssistantMessage(content, clientId, agentName) {
+    return commitAssistantMessageInternal(content, clientId, agentName);
+}
+
+/** @private Constant defining the method name for logging and validation context */
+const METHOD_NAME$w = "function.commit.commitAssistantMessageForce";
+/**
+ * Function implementation
+ */
+const commitAssistantMessageForceInternal = beginContext(async (content, clientId) => {
     // Log the commit attempt if enabled
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
         swarm$1.loggerService.log(METHOD_NAME$w, {
@@ -19523,22 +19801,31 @@ const commitAssistantMessageForce = beginContext(async (content, clientId) => {
     // Commit the assistant message via SessionPublicService without agent checks
     await swarm$1.sessionPublicService.commitAssistantMessage(content, METHOD_NAME$w, clientId, swarmName);
 });
+/**
+ * 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.
+ * Runs within a beginContext wrapper for execution context management, logging operations via LoggerService.
+ * Integrates with SessionValidationService (session and swarm retrieval), SwarmValidationService (swarm validation),
+ * SessionPublicService (message committing), and LoggerService (logging).
+ * Unlike commitAssistantMessage, this function skips agent validation and active agent checks, providing a more aggressive commit mechanism,
+ * analogous to cancelOutputForce vs. cancelOutput.
+ *
+ * @param {string} content - The content of the assistant message to commit, typically generated by an agent.
+ * @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 commitAssistantMessage).
+ * @returns {Promise<void>} A promise that resolves when the message is committed.
+ * @throws {Error} If session or swarm validation fails, propagated from respective validation services.
+ */
+function commitAssistantMessageForce(content, clientId) {
+    return commitAssistantMessageForceInternal(content, clientId);
+}
 
 /** @private Constant defining the method name for logging and validation context */
 const METHOD_NAME$v = "function.commit.cancelOutput";
 /**
- * Cancels the awaited output for a specific client and agent by emitting an empty string.
- * Validates the agent, session, and swarm, ensuring the current agent matches the provided agent before cancellation.
- * Runs within a beginContext wrapper for execution context management, logging operations via LoggerService.
- * Integrates with AgentValidationService (agent validation), SessionValidationService (session and swarm retrieval),
- * SwarmValidationService (swarm validation), and SwarmPublicService (agent retrieval and output cancellation).
- *
- * @param {string} clientId - The ID of the client whose output is to be canceled, validated against active sessions.
- * @param {string} agentName - The name of the agent for which the output is canceled, validated against registered agents.
- * @returns {Promise<void>} A promise that resolves when the output cancellation is complete or skipped (e.g., agent mismatch).
- * @throws {Error} If agent, session, or swarm validation fails, propagated from respective validation services.
+ * Function implementation
  */
-const cancelOutput = beginContext(async (clientId, agentName) => {
+const cancelOutputInternal = beginContext(async (clientId, agentName) => {
     // Log the cancellation attempt if enabled
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
         swarm$1.loggerService.log(METHOD_NAME$v, {
@@ -19566,23 +19853,28 @@ const cancelOutput = beginContext(async (clientId, agentName) => {
     // Perform the output cancellation via SwarmPublicService
     await swarm$1.swarmPublicService.cancelOutput(METHOD_NAME$v, clientId, swarmName);
 });
-
-/** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$u = "function.commit.cancelOutputForce";
 /**
- * Forcefully cancels the awaited output for a specific client by emitting an empty string, without checking the active agent.
- * Validates the session and swarm, then proceeds with cancellation regardless of the current agent state.
+ * 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.
  * Runs within a beginContext wrapper for execution context management, logging operations via LoggerService.
- * Integrates with SessionValidationService (session and swarm retrieval), SwarmValidationService (swarm validation),
- * SwarmPublicService (output cancellation), and LoggerService (logging).
- * Unlike cancelOutput, this function skips agent validation and active agent checks, providing a more aggressive cancellation mechanism.
+ * Integrates with AgentValidationService (agent validation), SessionValidationService (session and swarm retrieval),
+ * SwarmValidationService (swarm validation), and SwarmPublicService (agent retrieval and output cancellation).
  *
  * @param {string} clientId - The ID of the client whose output is to be canceled, validated against active sessions.
- * @param {string} agentName - The name of the agent (unused in this implementation, included for interface consistency with cancelOutput).
- * @returns {Promise<void>} A promise that resolves when the output cancellation is complete.
- * @throws {Error} If session or swarm validation fails, propagated from respective validation services.
+ * @param {string} agentName - The name of the agent for which the output is canceled, validated against registered agents.
+ * @returns {Promise<void>} A promise that resolves when the output cancellation is complete or skipped (e.g., agent mismatch).
+ * @throws {Error} If agent, session, or swarm validation fails, propagated from respective validation services.
  */
-const cancelOutputForce = beginContext(async (clientId) => {
+function cancelOutput(clientId, agentName) {
+    return cancelOutputInternal(clientId, agentName);
+}
+
+/** @private Constant defining the method name for logging and validation context */
+const METHOD_NAME$u = "function.commit.cancelOutputForce";
+/**
+ * Function implementation
+ */
+const cancelOutputForceInternal = beginContext(async (clientId) => {
     // Log the cancellation attempt if enabled
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
         swarm$1.loggerService.log(METHOD_NAME$u, {
@@ -19596,24 +19888,29 @@ const cancelOutputForce = beginContext(async (clientId) => {
     // Perform the output cancellation via SwarmPublicService without agent checks
     await swarm$1.swarmPublicService.cancelOutput(METHOD_NAME$u, clientId, swarmName);
 });
-
-/** @private Constant defining the method name for logging and validation context */
-const METHOD_NAME$t = "function.commit.commitStopToolsForce";
 /**
- * Forcefully prevents the next tool from being executed for a specific client in the swarm system, without checking the active agent.
- * Validates the session and swarm, then proceeds with stopping tool execution regardless of the current agent state.
+ * 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.
  * Runs within a beginContext wrapper for execution context management, logging operations via LoggerService.
  * Integrates with SessionValidationService (session and swarm retrieval), SwarmValidationService (swarm validation),
- * SessionPublicService (tool execution stop), ToolValidationService (tool context), and LoggerService (logging).
- * Unlike commitStopTools, this function skips agent validation and active agent checks, providing a more aggressive stop mechanism,
- * analogous to commitFlushForce vs. commitFlush.
+ * SwarmPublicService (output cancellation), and LoggerService (logging).
+ * Unlike cancelOutput, this function skips agent validation and active agent checks, providing a more aggressive cancellation mechanism.
  *
- * @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 commitStopTools).
- * @returns {Promise<void>} A promise that resolves when the tool stop is committed.
+ * @param {string} clientId - The ID of the client whose output is to be canceled, validated against active sessions.
+ * @param {string} agentName - The name of the agent (unused in this implementation, included for interface consistency with cancelOutput).
+ * @returns {Promise<void>} A promise that resolves when the output cancellation is complete.
  * @throws {Error} If session or swarm validation fails, propagated from respective validation services.
  */
-const commitStopToolsForce = beginContext(async (clientId) => {
+function cancelOutputForce(clientId) {
+    return cancelOutputForceInternal(clientId);
+}
+
+/** @private Constant defining the method name for logging and validation context */
+const METHOD_NAME$t = "function.commit.commitStopToolsForce";
+/**
+ * Function implementation
+ */
+const commitStopToolsForceInternal = beginContext(async (clientId) => {
     // Log the stop tools attempt if enabled
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
         swarm$1.loggerService.log(METHOD_NAME$t, {
@@ -19628,23 +19925,29 @@ const commitStopToolsForce = beginContext(async (clientId) => {
     // Commit the stop of the next tool execution via SessionPublicService without agent checks
     await swarm$1.sessionPublicService.commitStopTools(METHOD_NAME$t, clientId, swarmName);
 });
-
-const METHOD_NAME$s = "function.commit.commitToolRequest";
 /**
- * Commits a tool request to the active agent in the swarm system.
- * Validates the agent, session, and swarm, ensuring the current agent matches the provided agent before committing the request.
+ * 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.
  * Runs within a beginContext wrapper for execution context management, logging operations via LoggerService.
- * Integrates with AgentValidationService (agent validation), SessionValidationService (session and swarm retrieval),
- * SwarmValidationService (swarm validation), SwarmPublicService (agent retrieval), SessionPublicService (tool request committing),
- * and LoggerService (logging). Complements functions like commitSystemMessage by handling tool requests rather than system messages.
+ * Integrates with SessionValidationService (session and swarm retrieval), SwarmValidationService (swarm validation),
+ * SessionPublicService (tool execution stop), ToolValidationService (tool context), and LoggerService (logging).
+ * Unlike commitStopTools, this function skips agent validation and active agent checks, providing a more aggressive stop mechanism,
+ * analogous to commitFlushForce vs. commitFlush.
  *
- * @param {IToolRequest | IToolRequest[]} request - The tool request(s) to commit, either as a single request or an array of requests.
  * @param {string} clientId - The ID of the client associated with the session, validated against active sessions.
- * @param {string} agentName - The name of the agent to commit the request for, validated against registered agents.
- * @returns {Promise<string[] | null>} A promise that resolves with an array of results if the request is committed, or `null` if skipped (e.g., agent mismatch).
- * @throws {Error} If agent, session, or swarm validation fails, propagated from respective validation services.
+ * @param {string} agentName - The name of the agent (unused in this implementation, included for interface consistency with commitStopTools).
+ * @returns {Promise<void>} A promise that resolves when the tool stop is committed.
+ * @throws {Error} If session or swarm validation fails, propagated from respective validation services.
  */
-const commitToolRequest = beginContext(async (request, clientId, agentName) => {
+function commitStopToolsForce(clientId) {
+    return commitStopToolsForceInternal(clientId);
+}
+
+const METHOD_NAME$s = "function.commit.commitToolRequest";
+/**
+ * Function implementation
+ */
+const commitToolRequestInternal = beginContext(async (request, clientId, agentName) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
         swarm$1.loggerService.log(METHOD_NAME$s, {
             request,
@@ -19667,22 +19970,25 @@ const commitToolRequest = beginContext(async (request, clientId, agentName) => {
     }
     return await swarm$1.sessionPublicService.commitToolRequest(Array.isArray(request) ? request : [request], METHOD_NAME$s, clientId, swarmName);
 });
-
-const METHOD_NAME$r = "function.commit.commitToolRequestForce";
 /**
- * Forcefully commits a tool request to the active agent in the swarm system.
- * Validates the session and swarm, bypassing agent validation to directly commit the request.
+ * Commits a tool request to the active agent in the swarm system.
+ * Validates the agent, session, and swarm, ensuring the current agent matches the provided agent before committing the request.
  * Runs within a beginContext wrapper for execution context management, logging operations via LoggerService.
- * Integrates with SessionValidationService (session and swarm retrieval), SwarmValidationService (swarm validation),
- * SessionPublicService (tool request committing), and LoggerService (logging).
- * Complements functions like commitToolRequest by skipping agent validation for direct tool request commits.
  *
- * @param {IToolRequest | IToolRequest[]} request - The tool request(s) to commit, either as a single request or an array of requests.
- * @param {string} clientId - The ID of the client associated with the session, validated against active sessions.
- * @returns {Promise<string[]>} A promise that resolves with an array of results if the request is committed.
- * @throws {Error} If session or swarm validation fails, propagated from respective validation services.
+ * @param {IToolRequest | IToolRequest[]} request - The tool request(s) to commit.
+ * @param {string} clientId - The client ID associated with the session.
+ * @param {string} agentName - The agent name to commit the request for.
+ * @returns {Promise<string[] | null>} A promise resolving with an array of result strings, or null if skipped due to agent mismatch.
+ */
+function commitToolRequest(request, clientId, agentName) {
+    return commitToolRequestInternal(request, clientId, agentName);
+}
+
+const METHOD_NAME$r = "function.commit.commitToolRequestForce";
+/**
+ * Function implementation
  */
-const commitToolRequestForce = beginContext(async (request, clientId) => {
+const commitToolRequestForceInternal = beginContext(async (request, clientId) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
         swarm$1.loggerService.log(METHOD_NAME$r, {
             request,
@@ -19691,21 +19997,29 @@ const commitToolRequestForce = beginContext(async (request, clientId) => {
     swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$r);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$r);
-    return await swarm$1.sessionPublicService.commitToolRequest(Array.isArray(request) ? request : [request], METHOD_NAME$r, clientId, swarmName);
+    const requests = Array.isArray(request) ? request : [request];
+    return await swarm$1.sessionPublicService.commitToolRequest(requests, METHOD_NAME$r, clientId, swarmName);
 });
+/**
+ * Forcefully commits a tool request to the active agent in the swarm system.
+ * Validates the session and swarm, bypassing agent validation to directly commit the request.
+ * Runs within a beginContext wrapper for execution context management, logging operations via LoggerService.
+ *
+ * @param {IToolRequest | IToolRequest[]} request - The tool request(s) to commit.
+ * @param {string} clientId - The ID of the client associated with the session.
+ * @returns {Promise<string[]>} A promise that resolves with an array of results if the request is committed.
+ * @throws {Error} If session or swarm validation fails.
+ */
+function commitToolRequestForce(request, clientId) {
+    return commitToolRequestForceInternal(request, clientId);
+}
 
 /** @constant {string} METHOD_NAME - The name of the method used for logging and validation */
 const METHOD_NAME$q = "function.target.question";
 /**
- * Initiates a question process within a chat context
- * @function question
- * @param {string} message - The message/question to be processed
- * @param {string} clientId - Unique identifier for the client
- * @param {AgentName} agentName - Name of the agent handling the question
- * @param {WikiName} wikiName - Name of the wiki context
- * @returns {Promise<string>} The response from the chat process
+ * Function implementation
  */
-const question = beginContext(async (message, clientId, agentName, wikiName) => {
+const questionInternal = beginContext(async (message, clientId, agentName, wikiName) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
         swarm$1.loggerService.log(METHOD_NAME$q, {
             message,
@@ -19742,18 +20056,25 @@ const question = beginContext(async (message, clientId, agentName, wikiName) =>
     }
     return await getChat(args);
 });
-
-/** @constant {string} METHOD_NAME - The name of the method used for logging and validation */
-const METHOD_NAME$p = "function.target.questionForce";
 /**
- * Initiates a forced question process within a chat context
- * @function questionForce
+ * Initiates a question process within a chat context
+ * @function question
  * @param {string} message - The message/question to be processed
  * @param {string} clientId - Unique identifier for the client
+ * @param {AgentName} agentName - Name of the agent handling the question
  * @param {WikiName} wikiName - Name of the wiki context
  * @returns {Promise<string>} The response from the chat process
  */
-const questionForce = beginContext(async (message, clientId, wikiName) => {
+function question(message, clientId, agentName, wikiName) {
+    return questionInternal(message, clientId, agentName, wikiName);
+}
+
+/** @constant {string} METHOD_NAME - The name of the method used for logging and validation */
+const METHOD_NAME$p = "function.target.questionForce";
+/**
+ * Function implementation
+ */
+const questionForceInternal = beginContext(async (message, clientId, wikiName) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
         swarm$1.loggerService.log(METHOD_NAME$p, {
             message,
@@ -19776,6 +20097,17 @@ const questionForce = beginContext(async (message, clientId, wikiName) => {
     }
     return await getChat(args);
 });
+/**
+ * Initiates a forced question process within a chat context
+ * @function questionForce
+ * @param {string} message - The message/question to be processed
+ * @param {string} clientId - Unique identifier for the client
+ * @param {WikiName} wikiName - Name of the wiki context
+ * @returns {Promise<string>} The response from the chat process
+ */
+function questionForce(message, clientId, wikiName) {
+    return questionForceInternal(message, clientId, wikiName);
+}
 
 const METHOD_NAME$o = "function.target.disposeConnection";
 /**
@@ -19968,22 +20300,9 @@ const makeAutoDispose = beginContext((clientId, swarmName, { timeoutSeconds = DE
 
 const METHOD_NAME$m = "function.target.notify";
 /**
- * Sends a notification message as output from the swarm session without executing an incoming message.
- *
- * This function directly sends a provided string as output from the swarm session, bypassing message execution. It is designed exclusively
- * for sessions established via the "makeConnection" mode. The function validates the session, swarm, and specified agent, ensuring the agent
- * is still active before sending the notification. If the active agent has changed, the operation is skipped. The execution is wrapped in
- * `beginContext` for a clean environment, logs the operation if enabled, and throws an error if the session mode is not "makeConnection".
- *
- * @param {string} content - The content to be sent as the notification output.
- * @param {string} clientId - The unique identifier of the client session sending the notification.
- * @param {AgentName} agentName - The name of the agent intended to send the notification.
- * @returns {Promise<void>} A promise that resolves when the notification is sent, or resolves early if skipped due to an agent change.
- * @throws {Error} If the session mode is not "makeConnection", or if agent, session, or swarm validation fails.
- * @example
- * await notify("Direct output", "client-123", "AgentX"); // Sends "Direct output" if AgentX is active
+ * Function implementation
  */
-const notify = beginContext(async (content, clientId, agentName) => {
+const notifyInternal = 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$m, {
@@ -20015,24 +20334,31 @@ const notify = beginContext(async (content, clientId, agentName) => {
     // Notify the content directly via the session public service
     return await swarm$1.sessionPublicService.notify(content, METHOD_NAME$m, clientId, swarmName);
 });
-
-const METHOD_NAME$l = "function.target.notifyForce";
 /**
  * Sends a notification message as output from the swarm session without executing an incoming message.
  *
  * This function directly sends a provided string as output from the swarm session, bypassing message execution. It is designed exclusively
  * for sessions established via the "makeConnection" mode. The function validates the session, swarm, and specified agent, ensuring the agent
- * is still active before sending the notification. Will notify even if the agent was changed. The execution is wrapped in
+ * is still active before sending the notification. If the active agent has changed, the operation is skipped. The execution is wrapped in
  * `beginContext` for a clean environment, logs the operation if enabled, and throws an error if the session mode is not "makeConnection".
  *
  * @param {string} content - The content to be sent as the notification output.
  * @param {string} clientId - The unique identifier of the client session sending the notification.
- * @returns {Promise<void>} A promise that resolves when the notification is sent
+ * @param {AgentName} agentName - The name of the agent intended to send the notification.
+ * @returns {Promise<void>} A promise that resolves when the notification is sent, or resolves early if skipped due to an agent change.
  * @throws {Error} If the session mode is not "makeConnection", or if agent, session, or swarm validation fails.
  * @example
- * await notifyForce("Direct output", "client-123", "AgentX"); // Sends "Direct output" if AgentX is active
+ * await notify("Direct output", "client-123", "AgentX"); // Sends "Direct output" if AgentX is active
+ */
+function notify(content, clientId, agentName) {
+    return notifyInternal(content, clientId, agentName);
+}
+
+const METHOD_NAME$l = "function.target.notifyForce";
+/**
+ * Function implementation
  */
-const notifyForce = beginContext(async (content, clientId) => {
+const notifyForceInternal = 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$l, {
@@ -20051,27 +20377,30 @@ const notifyForce = beginContext(async (content, clientId) => {
     // Notify the content directly via the session public service
     return await swarm$1.sessionPublicService.notify(content, METHOD_NAME$l, clientId, swarmName);
 });
-
-const METHOD_NAME$k = "function.target.runStateless";
 /**
- * Executes a message statelessly with an agent in a swarm session, bypassing chat history.
+ * Sends a notification message as output from the swarm session without executing an incoming message.
  *
- * This function processes a command or message using the specified agent without appending it to the chat history, designed to prevent
- * model history overflow when handling storage output or one-off tasks. It validates the agent, session, and swarm, checks if the specified
- * agent is still active, and executes the content with performance tracking and event bus notifications. The execution is wrapped in
- * `beginContext` for a clean environment and `ExecutionContextService` for metadata tracking. If the active agent has changed, the operation
- * is skipped, returning an empty string.
+ * This function directly sends a provided string as output from the swarm session, bypassing message execution. It is designed exclusively
+ * for sessions established via the "makeConnection" mode. The function validates the session, swarm, and specified agent, ensuring the agent
+ * is still active before sending the notification. Will notify even if the agent was changed. The execution is wrapped in
+ * `beginContext` for a clean environment, logs the operation if enabled, and throws an error if the session mode is not "makeConnection".
  *
- * @param {string} content - The content or command to be executed statelessly by the agent.
- * @param {string} clientId - The unique identifier of the client session requesting the execution.
- * @param {AgentName} agentName - The name of the agent intended to execute the command.
- * @returns {Promise<string>} A promise that resolves to the result of the execution, or an empty string if skipped due to an agent change.
- * @throws {Error} If agent, session, or swarm validation fails, or if the execution process encounters an error.
+ * @param {string} content - The content to be sent as the notification output.
+ * @param {string} clientId - The unique identifier of the client session sending the notification.
+ * @returns {Promise<void>} A promise that resolves when the notification is sent
+ * @throws {Error} If the session mode is not "makeConnection", or if agent, session, or swarm validation fails.
  * @example
- * const result = await runStateless("Process this data", "client-123", "AgentX");
- * console.log(result); // Outputs the agent's response without affecting history
+ * await notifyForce("Direct output", "client-123", "AgentX"); // Sends "Direct output" if AgentX is active
+ */
+function notifyForce(content, clientId) {
+    return notifyForceInternal(content, clientId);
+}
+
+const METHOD_NAME$k = "function.target.runStateless";
+/**
+ * Function implementation
  */
-const runStateless = beginContext(async (content, clientId, agentName) => {
+const runStatelessInternal = 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 &&
@@ -20125,25 +20454,33 @@ const runStateless = beginContext(async (content, clientId, agentName) => {
         processId: GLOBAL_CONFIG.CC_PROCESS_UUID,
     });
 });
-
-const METHOD_NAME$j = "function.target.runStatelessForce";
 /**
- * Executes a message statelessly with the active agent in a swarm session, bypassing chat history and forcing execution regardless of agent activity.
+ * Executes a message statelessly with an agent in a swarm session, bypassing chat history.
  *
- * This function processes a command or message using the active agent without appending it to the chat history, designed to prevent model history
- * overflow when handling storage output or one-off tasks. Unlike `runStateless`, 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.
+ * This function processes a command or message using the specified agent without appending it to the chat history, designed to prevent
+ * model history overflow when handling storage output or one-off tasks. It validates the agent, session, and swarm, checks if the specified
+ * agent is still active, and executes the content with performance tracking and event bus notifications. The execution is wrapped in
+ * `beginContext` for a clean environment and `ExecutionContextService` for metadata tracking. If the active agent has changed, the operation
+ * is skipped, returning an empty string.
  *
- * @param {string} content - The content or command to be executed statelessly by the active agent.
+ * @param {string} content - The content or command to be executed statelessly by the 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.
+ * @param {AgentName} agentName - The name of the agent intended to execute the command.
+ * @returns {Promise<string>} A promise that resolves to the result of the execution, or an empty string if skipped due to an agent change.
+ * @throws {Error} If agent, session, or swarm validation fails, or if the execution process encounters an error.
  * @example
- * const result = await runStatelessForce("Process this data forcefully", "client-123");
+ * const result = await runStateless("Process this data", "client-123", "AgentX");
  * console.log(result); // Outputs the agent's response without affecting history
  */
-const runStatelessForce = beginContext(async (content, clientId) => {
+function runStateless(content, clientId, agentName) {
+    return runStatelessInternal(content, clientId, agentName);
+}
+
+const METHOD_NAME$j = "function.target.runStatelessForce";
+/**
+ * Function implementation
+ */
+const runStatelessForceInternal = 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 &&
@@ -20178,6 +20515,25 @@ const runStatelessForce = beginContext(async (content, clientId) => {
         processId: GLOBAL_CONFIG.CC_PROCESS_UUID,
     });
 });
+/**
+ * Executes a message statelessly with the active agent in a swarm session, bypassing chat history and forcing execution regardless of agent activity.
+ *
+ * This function processes a command or message using the active agent without appending it to the chat history, designed to prevent model history
+ * overflow when handling storage output or one-off tasks. Unlike `runStateless`, 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 statelessly 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 runStatelessForce("Process this data forcefully", "client-123");
+ * console.log(result); // Outputs the agent's response without affecting history
+ */
+function runStatelessForce(content, clientId) {
+    return runStatelessForceInternal(content, clientId);
+}
 
 /**
  * Delay in milliseconds for scheduled message sending.
@@ -20719,15 +21075,9 @@ session.rate = (clientId, swarmName, { delay = SCHEDULED_DELAY, onDispose } = {}
  */
 const METHOD_NAME$f = "function.target.fork";
 /**
- * @function fork
- * @description Executes a provided function within a managed scope, handling session creation, validation, and cleanup.
- * @template T - Type of the result returned by the run function.
- * @param {Function} runFn - The function to execute, receiving clientId and agentName as arguments.
- * @param {IScopeOptions} options - Configuration options for the scope operation.
- * @returns {Promise<T | void>} The result of the run function or void if no result is returned.
- * @throws {Error} If a session already exists for the clientId.
+ * Function implementation
  */
-const fork = beginContext(async (runFn, { clientId, swarmName, onError }) => {
+const forkInternal = beginContext(async (runFn, { clientId, swarmName, onError }) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
         swarm$1.loggerService.log(METHOD_NAME$f, {
             clientId,
@@ -20753,6 +21103,17 @@ const fork = beginContext(async (runFn, { clientId, swarmName, onError }) => {
     }
     return result;
 });
+/**
+ * Executes a provided function within a managed scope, handling session creation, validation, and cleanup.
+ * @template T - Type of the result returned by the run function.
+ * @param {Function} runFn - The function to execute, receiving clientId and agentName as arguments.
+ * @param {IScopeOptions} options - Configuration options for the scope operation.
+ * @returns {Promise<T | void>} The result of the run function or void if no result is returned.
+ * @throws {Error} If a session already exists for the clientId.
+ */
+function fork(runFn, options) {
+    return forkInternal(runFn, options);
+}
 
 /**
  * @module scope
@@ -20765,14 +21126,9 @@ const fork = beginContext(async (runFn, { clientId, swarmName, onError }) => {
  */
 const METHOD_NAME$e = "function.target.scope";
 /**
- * @function scope
- * @description Executes a provided function within a schema context, with optional overrides for schema services such as agents, completions, and pipelines.
- * @template T - Type of the result returned by the run function.
- * @param {Function} runFn - The function to execute within the schema context.
- * @param {Partial<ISchemaContext["registry"]>} [options] - Optional overrides for schema services, with defaults from the swarm's schema services.
- * @returns {Promise<T>} The result of the executed function.
+ * Function implementation
  */
-const scope = beginContext(async (runFn, { agentSchemaService = swarm$1.agentSchemaService.registry, completionSchemaService = swarm$1.completionSchemaService.registry, computeSchemaService = swarm$1.computeSchemaService.registry, embeddingSchemaService = swarm$1.embeddingSchemaService.registry, mcpSchemaService = swarm$1.mcpSchemaService.registry, pipelineSchemaService = swarm$1.pipelineSchemaService.registry, policySchemaService = swarm$1.policySchemaService.registry, stateSchemaService = swarm$1.stateSchemaService.registry, storageSchemaService = swarm$1.storageSchemaService.registry, swarmSchemaService = swarm$1.swarmSchemaService.registry, toolSchemaService = swarm$1.toolSchemaService.registry, wikiSchemaService = swarm$1.wikiSchemaService.registry, } = {}) => {
+const scopeInternal = beginContext(async (runFn, { agentSchemaService = swarm$1.agentSchemaService.registry, completionSchemaService = swarm$1.completionSchemaService.registry, computeSchemaService = swarm$1.computeSchemaService.registry, embeddingSchemaService = swarm$1.embeddingSchemaService.registry, mcpSchemaService = swarm$1.mcpSchemaService.registry, pipelineSchemaService = swarm$1.pipelineSchemaService.registry, policySchemaService = swarm$1.policySchemaService.registry, stateSchemaService = swarm$1.stateSchemaService.registry, storageSchemaService = swarm$1.storageSchemaService.registry, swarmSchemaService = swarm$1.swarmSchemaService.registry, toolSchemaService = swarm$1.toolSchemaService.registry, wikiSchemaService = swarm$1.wikiSchemaService.registry, } = {}) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$e);
     return await SchemaContextService.runInContext(runFn, {
         registry: {
@@ -20791,6 +21147,16 @@ const scope = beginContext(async (runFn, { agentSchemaService = swarm$1.agentSch
         },
     });
 });
+/**
+ * Executes a provided function within a schema context, with optional overrides for schema services such as agents, completions, and pipelines.
+ * @template T - Type of the result returned by the run function.
+ * @param {Function} runFn - The function to execute within the schema context.
+ * @param {Partial<ISchemaContext["registry"]>} [options] - Optional overrides for schema services, with defaults from the swarm's schema services.
+ * @returns {Promise<T>} The result of the executed function.
+ */
+function scope(runFn, options) {
+    return scopeInternal(runFn, options);
+}
 
 /**
  * @module startPipeline
@@ -20803,17 +21169,9 @@ const scope = beginContext(async (runFn, { agentSchemaService = swarm$1.agentSch
  */
 const METHOD_NAME$d = "function.target.startPipeline";
 /**
- * @function startPipeline
- * @description Executes a pipeline with the specified name, handling session creation, validation, and lifecycle callbacks.
- * @template Payload - Type extending object for the pipeline payload.
- * @template T - Type of the result returned by the pipeline execution.
- * @param {string} clientId - The client identifier.
- * @param {PipelineName} pipelineName - The name of the pipeline to execute.
- * @param {AgentName} agentName - The name of the agent associated with the pipeline.
- * @param {Payload} [payload={}] - Optional payload data for the pipeline.
- * @returns {Promise<T>} The result of the pipeline execution.
+ * Function implementation
  */
-const startPipeline = beginContext(async (clientId, pipelineName, agentName, payload = {}) => {
+const startPipelineInternal = beginContext(async (clientId, pipelineName, agentName, payload = {}) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
         swarm$1.loggerService.log(METHOD_NAME$d, {
             clientId,
@@ -20851,9 +21209,31 @@ const startPipeline = beginContext(async (clientId, pipelineName, agentName, pay
     }
     return result;
 });
+/**
+ * @function startPipeline
+ * @description Executes a pipeline with the specified name, handling session creation, validation, and lifecycle callbacks.
+ * @template Payload - Type extending object for the pipeline payload.
+ * @template T - Type of the result returned by the pipeline execution.
+ * @param {string} clientId - The client identifier.
+ * @param {PipelineName} pipelineName - The name of the pipeline to execute.
+ * @param {AgentName} agentName - The name of the agent associated with the pipeline.
+ * @param {Payload} [payload={}] - Optional payload data for the pipeline.
+ * @returns {Promise<T>} The result of the pipeline execution.
+ */
+function startPipeline(clientId, pipelineName, agentName, payload) {
+    return startPipelineInternal(clientId, pipelineName, agentName, payload);
+}
 
 /** @private Constant defining the method name for logging purposes */
 const METHOD_NAME$c = "function.common.hasSession";
+/**
+ * Function implementation
+ */
+const hasSessionInternal = (clientId) => {
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
+        swarm$1.loggerService.log(METHOD_NAME$c, { clientId });
+    return swarm$1.sessionValidationService.hasSession(clientId);
+};
 /**
  * Checks if a session exists for the given client ID.
  *
@@ -20863,29 +21243,15 @@ const METHOD_NAME$c = "function.common.hasSession";
  * @param {string} clientId - The unique identifier of the client whose session is being validated.
  * @returns {boolean} `true` if the session exists, otherwise `false`.
  */
-const hasSession = (clientId) => {
-    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$c, { clientId });
-    return swarm$1.sessionValidationService.hasSession(clientId);
-};
+function hasSession(clientId) {
+    return hasSessionInternal(clientId);
+}
 
 const METHOD_NAME$b = "function.common.getAgentHistory";
 /**
- * Retrieves the history prepared for a specific agent, incorporating rescue algorithm tweaks.
- *
- * This function fetches the history tailored for a specified agent within a swarm session, applying any rescue strategies defined in the system (e.g., `CC_RESQUE_STRATEGY` from `GLOBAL_CONFIG`).
- * It validates the client session and agent, logs the operation if enabled, and retrieves the history using the agent's prompt configuration via the history 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} clientId - The unique identifier of the client session requesting the history.
- * @param {AgentName} agentName - The name of the agent whose history is being retrieved.
- * @returns {Promise<IModelMessage[]>} A promise that resolves to an array of history messages (`IModelMessage[]`) prepared for the agent, including any rescue algorithm adjustments.
- * @throws {Error} If validation fails (e.g., invalid session or agent) or if the history public service encounters an error during retrieval.
- * @example
- * const history = await getAgentHistory("client-123", "AgentX");
- * console.log(history); // Outputs array of IModelMessage objects
+ * Function implementation
  */
-const getAgentHistory = beginContext(async (clientId, agentName) => {
+const getAgentHistoryInternal = 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$b, {
@@ -20902,23 +21268,27 @@ const getAgentHistory = beginContext(async (clientId, agentName) => {
     // Return a shallow copy of the history array
     return [...history];
 });
-
-const METHOD_NAME$a = "function.common.getSessionMode";
 /**
- * Retrieves the session mode for a given client session in a swarm.
+ * Retrieves the history prepared for a specific agent, incorporating rescue algorithm tweaks.
  *
- * This function returns the current mode of the specified client session, which can be one of `"session"`, `"makeConnection"`, or `"complete"`.
- * It validates the client session and associated swarm, logs the operation if enabled, and fetches the session mode using the session validation service.
+ * This function fetches the history tailored for a specified agent within a swarm session, applying any rescue strategies defined in the system (e.g., `CC_RESQUE_STRATEGY` from `GLOBAL_CONFIG`).
+ * It validates the client session and agent, logs the operation if enabled, and retrieves the history using the agent's prompt configuration via the history 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} clientId - The unique identifier of the client session whose mode is being retrieved.
- * @returns {Promise<"session" | "makeConnection" | "complete">} A promise that resolves to the session mode, indicating the current state of the session.
- * @throws {Error} If the client session is invalid, the swarm validation fails, or the session validation service encounters an error during mode retrieval.
+ * @param {string} clientId - The unique identifier of the client session requesting the history.
+ * @param {AgentName} agentName - The name of the agent whose history is being retrieved.
+ * @returns {Promise<IModelMessage[]>} A promise that resolves to an array of history messages (`IModelMessage[]`) prepared for the agent, including any rescue algorithm adjustments.
+ * @throws {Error} If validation fails (e.g., invalid session or agent) or if the history public service encounters an error during retrieval.
  * @example
- * const mode = await getSessionMode("client-123");
- * console.log(mode); // Outputs "session", "makeConnection", or "complete"
+ * const history = await getAgentHistory("client-123", "AgentX");
+ * console.log(history); // Outputs array of IModelMessage objects
  */
-const getSessionMode = beginContext(async (clientId) => {
+function getAgentHistory(clientId, agentName) {
+    return getAgentHistoryInternal(clientId, agentName);
+}
+
+const METHOD_NAME$a = "function.common.getSessionMode";
+const getSessionModeInternal = 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$a, {
@@ -20931,22 +21301,29 @@ const getSessionMode = beginContext(async (clientId) => {
     // Retrieve the session mode from the session validation service
     return swarm$1.sessionValidationService.getSessionMode(clientId);
 });
-
-const METHOD_NAME$9 = "function.common.getSessionContext";
 /**
- * Retrieves the session context for the current execution environment.
+ * Retrieves the session mode for a given client session in a swarm.
  *
- * This function constructs and returns the session context, including the client ID, process ID, and available method and execution contexts.
- * It logs the operation if enabled, checks for active contexts using the `MethodContextService` and `ExecutionContextService`, and derives the client ID from either context if available.
- * Unlike other functions, it does not perform explicit validation or require a `clientId` parameter, as it relies on the current execution environment's state.
+ * This function returns the current mode of the specified client session, which can be one of `"session"`, `"makeConnection"`, or `"complete"`.
+ * It validates the client session and associated swarm, logs the operation if enabled, and fetches the session mode using the session validation service.
+ * The execution is wrapped in `beginContext` to ensure it runs outside of existing method and execution contexts, providing a clean execution environment.
  *
- * @returns {Promise<ISessionContext>} A promise that resolves to an object containing the session context, including `clientId`, `processId`, `methodContext`, and `executionContext`.
- * @throws {Error} If an unexpected error occurs while accessing the method or execution context services (though typically none are thrown in this implementation).
+ * @param {string} clientId - The unique identifier of the client session whose mode is being retrieved.
+ * @returns {Promise<"session" | "makeConnection" | "complete">} A promise that resolves to the session mode, indicating the current state of the session.
+ * @throws {Error} If the client session is invalid, the swarm validation fails, or the session validation service encounters an error during mode retrieval.
  * @example
- * const context = await getSessionContext();
- * console.log(context); // Outputs { clientId: "client-123", processId: "uuid-xyz", methodContext: {...}, executionContext: {...} }
+ * const mode = await getSessionMode("client-123");
+ * console.log(mode); // Outputs "session", "makeConnection", or "complete"
+ */
+function getSessionMode(clientId) {
+    return getSessionModeInternal(clientId);
+}
+
+const METHOD_NAME$9 = "function.common.getSessionContext";
+/**
+ * Function implementation
  */
-const getSessionContext = async () => {
+const getSessionContextInternal = async () => {
     // Log the operation if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
         swarm$1.loggerService.log(METHOD_NAME$9);
@@ -20968,6 +21345,22 @@ const getSessionContext = async () => {
         executionContext,
     };
 };
+/**
+ * Retrieves the session context for the current execution environment.
+ *
+ * This function constructs and returns the session context, including the client ID, process ID, and available method and execution contexts.
+ * It logs the operation if enabled, checks for active contexts using the `MethodContextService` and `ExecutionContextService`, and derives the client ID from either context if available.
+ * Unlike other functions, it does not perform explicit validation or require a `clientId` parameter, as it relies on the current execution environment's state.
+ *
+ * @returns {Promise<ISessionContext>} A promise that resolves to an object containing the session context, including `clientId`, `processId`, `methodContext`, and `executionContext`.
+ * @throws {Error} If an unexpected error occurs while accessing the method or execution context services (though typically none are thrown in this implementation).
+ * @example
+ * const context = await getSessionContext();
+ * console.log(context); // Outputs { clientId: "client-123", processId: "uuid-xyz", methodContext: {...}, executionContext: {...} }
+ */
+function getSessionContext() {
+    return getSessionContextInternal();
+}
 
 /**
  * @private Constant defining the method name for logging purposes.
@@ -20975,14 +21368,9 @@ const getSessionContext = async () => {
  */
 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.
+ * Function implementation
  */
-const getNavigationRoute = (clientId, swarmName) => {
+const getNavigationRouteInternal = (clientId, swarmName) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
         swarm$1.loggerService.log(METHOD_NAME$8, {
             clientId,
@@ -20991,8 +21379,32 @@ const getNavigationRoute = (clientId, swarmName) => {
     swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$8);
     return swarm$1.navigationValidationService.getNavigationRoute(clientId, swarmName);
 };
+/**
+ * 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.
+ */
+function getNavigationRoute(clientId, swarmName) {
+    return getNavigationRouteInternal(clientId, swarmName);
+}
 
 const METHOD_NAME$7 = "function.history.getUserHistory";
+/**
+ * Function implementation
+ */
+const getUserHistoryInternal = 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, {
+            clientId,
+        });
+    // Fetch raw history and filter for user role and mode
+    const history = await getRawHistoryInternal(clientId, METHOD_NAME$7);
+    return history.filter(({ role, mode }) => role === "user" && mode === "user");
+});
 /**
  * Retrieves the user-specific history entries for a given client session.
  *
@@ -21007,18 +21419,24 @@ const METHOD_NAME$7 = "function.history.getUserHistory";
  * const userHistory = await getUserHistory("client-123");
  * console.log(userHistory); // Outputs array of user history entries
  */
-const getUserHistory = beginContext(async (clientId) => {
+function getUserHistory(clientId) {
+    return getUserHistoryInternal(clientId);
+}
+
+const METHOD_NAME$6 = "function.history.getAssistantHistory";
+/**
+ * Function implementation
+ */
+const getAssistantHistoryInternal = 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$6, {
             clientId,
         });
-    // Fetch raw history and filter for user role and mode
-    const history = await getRawHistory(clientId, METHOD_NAME$7);
-    return history.filter(({ role, mode }) => role === "user" && mode === "user");
+    // Fetch raw history and filter for assistant role
+    const history = await getRawHistoryInternal(clientId, METHOD_NAME$6);
+    return history.filter(({ role }) => role === "assistant");
 });
-
-const METHOD_NAME$6 = "function.history.getAssistantHistory";
 /**
  * Retrieves the assistant's history entries for a given client session.
  *
@@ -21033,18 +21451,25 @@ const METHOD_NAME$6 = "function.history.getAssistantHistory";
  * const assistantHistory = await getAssistantHistory("client-123");
  * console.log(assistantHistory); // Outputs array of assistant history entries
  */
-const getAssistantHistory = beginContext(async (clientId) => {
+function getAssistantHistory(clientId) {
+    return getAssistantHistoryInternal(clientId);
+}
+
+const METHOD_NAME$5 = "function.history.getLastAssistantMessage";
+/**
+ * Function implementation
+ */
+const getLastAssistantMessageInternal = 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$5, {
             clientId,
         });
-    // Fetch raw history and filter for assistant role
-    const history = await getRawHistory(clientId, METHOD_NAME$6);
-    return history.filter(({ role }) => role === "assistant");
+    // Fetch raw history and find the last assistant message
+    const history = await getRawHistoryInternal(clientId, METHOD_NAME$5);
+    const last = history.findLast(({ role }) => role === "assistant");
+    return last?.content ? last.content : null;
 });
-
-const METHOD_NAME$5 = "function.history.getLastAssistantMessage";
 /**
  * Retrieves the content of the most recent assistant message from a client's session history.
  *
@@ -21059,19 +21484,25 @@ const METHOD_NAME$5 = "function.history.getLastAssistantMessage";
  * const lastMessage = await getLastAssistantMessage("client-123");
  * console.log(lastMessage); // Outputs the last assistant message or null
  */
-const getLastAssistantMessage = beginContext(async (clientId) => {
+function getLastAssistantMessage(clientId) {
+    return getLastAssistantMessageInternal(clientId);
+}
+
+const METHOD_NAME$4 = "function.history.getLastSystemMessage";
+/**
+ * Function implementation
+ */
+const getLastSystemMessageInternal = 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$5, {
+        swarm$1.loggerService.log(METHOD_NAME$4, {
             clientId,
         });
-    // Fetch raw history and find the last assistant message
-    const history = await getRawHistory(clientId, METHOD_NAME$5);
-    const last = history.findLast(({ role }) => role === "assistant");
-    return last?.content ? last.content : null;
+    // Fetch raw history and find the last system message
+    const history = await getRawHistoryInternal(clientId, METHOD_NAME$4);
+    const last = history.findLast(({ role }) => role === "system");
+    return last ? last.content : null;
 });
-
-const METHOD_NAME$4 = "function.history.getLastSystemMessage";
 /**
  * Retrieves the content of the most recent system message from a client's session history.
  *
@@ -21086,17 +21517,9 @@ const METHOD_NAME$4 = "function.history.getLastSystemMessage";
  * const lastMessage = await getLastSystemMessage("client-123");
  * console.log(lastMessage); // Outputs the last system message or null
  */
-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$4, {
-            clientId,
-        });
-    // Fetch raw history and find the last system message
-    const history = await getRawHistory(clientId, METHOD_NAME$4);
-    const last = history.findLast(({ role }) => role === "system");
-    return last ? last.content : null;
-});
+function getLastSystemMessage(clientId) {
+    return getLastSystemMessageInternal(clientId);
+}
 
 const METHOD_NAME$3 = "function.event.listenEvent";
 /**
@@ -21114,24 +21537,9 @@ const DISALLOWED_EVENT_SOURCE_LIST$2 = new Set([
     "policy-bus",
 ]);
 /**
- * Emits a custom event to the swarm bus service.
- *
- * This function sends a custom event with a specified topic and payload to the swarm's bus service, allowing clients to broadcast messages
- * for other components to listen to. It is wrapped in `beginContext` for a clean execution environment and logs the operation if enabled.
- * The function enforces a restriction on reserved topic names (defined in `DISALLOWED_EVENT_SOURCE_LIST`), throwing an error if a reserved
- * topic is used. The event is structured as an `ICustomEvent` with the provided `clientId`, `topicName` as the source, and `payload`.
- *
- * @template T - The type of the payload, defaulting to `any` if unspecified.
- * @param {string} clientId - The unique identifier of the client emitting the event.
- * @param {string} topicName - The name of the event topic (must not be a reserved source).
- * @param {T} payload - The payload data to be included in the event.
- * @returns {Promise<void>} A promise that resolves when the event is successfully emitted.
- * @throws {Error} If the `topicName` is a reserved event source (e.g., "agent-bus", "session-bus").
- * @example
- * await event("client-123", "custom-topic", { message: "Hello, swarm!" });
- * // Emits an event with topic "custom-topic" and payload { message: "Hello, swarm!" }
+ * Function implementation
  */
-const event = beginContext((clientId, topicName, payload) => {
+const eventInternal = 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$3, {
@@ -21148,6 +21556,27 @@ const event = beginContext((clientId, topicName, payload) => {
         clientId,
     });
 });
+/**
+ * Emits a custom event to the swarm bus service.
+ *
+ * This function sends a custom event with a specified topic and payload to the swarm's bus service, allowing clients to broadcast messages
+ * for other components to listen to. It is wrapped in `beginContext` for a clean execution environment and logs the operation if enabled.
+ * The function enforces a restriction on reserved topic names (defined in `DISALLOWED_EVENT_SOURCE_LIST`), throwing an error if a reserved
+ * topic is used. The event is structured as an `ICustomEvent` with the provided `clientId`, `topicName` as the source, and `payload`.
+ *
+ * @template T - The type of the payload, defaulting to `any` if unspecified.
+ * @param {string} clientId - The unique identifier of the client emitting the event.
+ * @param {string} topicName - The name of the event topic (must not be a reserved source).
+ * @param {T} payload - The payload data to be included in the event.
+ * @returns {Promise<void>} A promise that resolves when the event is successfully emitted.
+ * @throws {Error} If the `topicName` is a reserved event source (e.g., "agent-bus", "session-bus").
+ * @example
+ * await event("client-123", "custom-topic", { message: "Hello, swarm!" });
+ * // Emits an event with topic "custom-topic" and payload { message: "Hello, swarm!" }
+ */
+function event(clientId, topicName, payload) {
+    return eventInternal(clientId, topicName, payload);
+}
 
 const METHOD_NAME$2 = "function.event.listenEvent";
 /**
@@ -21178,6 +21607,24 @@ const validateClientId$g = (clientId) => {
         throw new Error(`agent-swarm listenEvent session not found for clientId=${clientId}`);
     }
 };
+/**
+ * Function implementation
+ */
+const listenEventInternal = 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$2, {
+            clientId,
+        });
+    // Check if the topic name is reserved
+    if (DISALLOWED_EVENT_SOURCE_LIST$1.has(topicName)) {
+        throw new Error(`agent-swarm listenEvent topic is reserved topicName=${topicName}`);
+    }
+    // Validate the client ID
+    validateClientId$g(clientId);
+    // Subscribe to the event with a queued callback
+    return swarm$1.busService.subscribe(clientId, topicName, functoolsKit.queued(async ({ payload }) => await fn(payload)));
+});
 /**
  * Subscribes to a custom event on the swarm bus service and executes a callback when the event is received.
  *
@@ -21198,21 +21645,9 @@ const validateClientId$g = (clientId) => {
  * // Logs payload when "custom-topic" event is received for "client-123"
  * unsubscribe(); // Stops listening
  */
-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$2, {
-            clientId,
-        });
-    // Check if the topic name is reserved
-    if (DISALLOWED_EVENT_SOURCE_LIST$1.has(topicName)) {
-        throw new Error(`agent-swarm listenEvent topic is reserved topicName=${topicName}`);
-    }
-    // Validate the client ID
-    validateClientId$g(clientId);
-    // Subscribe to the event with a queued callback
-    return swarm$1.busService.subscribe(clientId, topicName, functoolsKit.queued(async ({ payload }) => await fn(payload)));
-});
+function listenEvent(clientId, topicName, fn) {
+    return listenEventInternal(clientId, topicName, fn);
+}
 
 const METHOD_NAME$1 = "function.event.listenEventOnce";
 /**
@@ -21243,6 +21678,24 @@ const validateClientId$f = (clientId) => {
         throw new Error(`agent-swarm listenEventOnce session not found for clientId=${clientId}`);
     }
 };
+/**
+ * Function implementation
+ */
+const listenEventOnceInternal = 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$1, {
+            clientId,
+        });
+    // Check if the topic name is reserved
+    if (DISALLOWED_EVENT_SOURCE_LIST.has(topicName)) {
+        throw new Error(`agent-swarm listenEventOnce topic is reserved topicName=${topicName}`);
+    }
+    // Validate the client ID
+    validateClientId$f(clientId);
+    // Subscribe to the event for one occurrence with a filter and queued callback
+    return swarm$1.busService.once(clientId, topicName, ({ payload }) => filterFn(payload), functoolsKit.queued(async ({ payload }) => await fn(payload)));
+});
 /**
  * Subscribes to a custom event on the swarm bus service for a single occurrence, executing a callback when the event matches a filter.
  *
@@ -21269,21 +21722,9 @@ const validateClientId$f = (clientId) => {
  * // Logs payload once when "custom-topic" event with value > 0 is received
  * unsubscribe(); // Cancels listener if not yet triggered
  */
-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$1, {
-            clientId,
-        });
-    // Check if the topic name is reserved
-    if (DISALLOWED_EVENT_SOURCE_LIST.has(topicName)) {
-        throw new Error(`agent-swarm listenEventOnce topic is reserved topicName=${topicName}`);
-    }
-    // Validate the client ID
-    validateClientId$f(clientId);
-    // Subscribe to the event for one occurrence with a filter and queued callback
-    return swarm$1.busService.once(clientId, topicName, ({ payload }) => filterFn(payload), functoolsKit.queued(async ({ payload }) => await fn(payload)));
-});
+function listenEventOnce(clientId, topicName, filterFn, fn) {
+    return listenEventOnceInternal(clientId, topicName, filterFn, fn);
+}
 
 const METHOD_NAME = "function.navigate.changeToPrevAgent";
 /**
@@ -21331,19 +21772,9 @@ const createGc = functoolsKit.singleshot(async () => {
     });
 });
 /**
- * Navigates back to the previous or default agent for a given client session in a swarm.
- *
- * This function switches the active agent to the previous agent in the navigation stack, or the default agent if no previous agent exists,
- * as determined by the `navigationPop` method. It validates the session and 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 agent change is complete. If navigation stack contains recursion does nothing
- * @throws {Error} If session or agent validation fails, or if the agent change process encounters an error.
- * @example
- * await changeToPrevAgent("client-123");
+ * Function implementation
  */
-const changeToPrevAgent = beginContext(async (clientId) => {
+const changeToPrevAgentInternal = 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, {
@@ -21361,6 +21792,22 @@ const changeToPrevAgent = beginContext(async (clientId) => {
     createGc();
     return await run(METHOD_NAME, agentName, swarmName);
 });
+/**
+ * Navigates back to the previous or default agent for a given client session in a swarm.
+ *
+ * This function switches the active agent to the previous agent in the navigation stack, or the default agent if no previous agent exists,
+ * as determined by the `navigationPop` method. It validates the session and 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 agent change is complete. If navigation stack contains recursion does nothing
+ * @throws {Error} If session or agent validation fails, or if the agent change process encounters an error.
+ * @example
+ * await changeToPrevAgent("client-123");
+ */
+function changeToPrevAgent(clientId) {
+    return changeToPrevAgentInternal(clientId);
+}
 
 /**
  * Validates the client ID for agent event listening, allowing wildcard "*" or checking for an active session.