agent-swarm-kit 1.1.167 → 1.1.169

package/build/index.cjs

@@ -4626,26 +4626,26 @@ class ClientOperator {
     }
 }
 
-const METHOD_NAME$1K = "function.commit.commitToolOutput";
+const METHOD_NAME$1L = "function.commit.commitToolOutput";
 /**
  * Function implementation
 */
 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$1K, {
+        swarm$1.loggerService.log(METHOD_NAME$1L, {
             toolId,
             content,
             clientId,
             agentName,
         });
     // Validate the agent, session, and swarm to ensure they exist and are accessible
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1K);
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1K);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1L);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1L);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1K);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1L);
     // Check if the specified agent is still the active agent in the swarm session
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1K, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1L, clientId, swarmName);
     if (currentAgentName !== agentName) {
         // Log a skip message if the agent has changed during the operation
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
@@ -4658,7 +4658,7 @@ const commitToolOutputInternal = beginContext(async (toolId, content, clientId,
         return;
     }
     // Commit the tool output to the session via the session public service
-    await swarm$1.sessionPublicService.commitToolOutput(toolId, content, METHOD_NAME$1K, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitToolOutput(toolId, content, METHOD_NAME$1L, clientId, swarmName);
 });
 /**
  * Commits the output of a tool execution to the active agent in a swarm session.
@@ -4683,7 +4683,7 @@ async function commitToolOutput(toolId, content, clientId, agentName) {
 const disposeSubject = new functoolsKit.Subject();
 const errorSubject = new functoolsKit.Subject();
 
-const METHOD_NAME$1J = "function.target.execute";
+const METHOD_NAME$1K = "function.target.execute";
 /**
  * Function implementation
 */
@@ -4691,19 +4691,19 @@ 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 &&
-        swarm$1.loggerService.log(METHOD_NAME$1J, {
+        swarm$1.loggerService.log(METHOD_NAME$1K, {
             content,
             clientId,
             agentName,
             executionId,
         });
     // Validate the agent, session, and swarm
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1J);
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1J);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1K);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1K);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1J);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1K);
     // Check if the specified agent is still the active agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1J, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1K, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "execute" skipped due to the agent change', {
@@ -4729,7 +4729,7 @@ const executeInternal = beginContext(async (content, clientId, agentName) => {
                     errorValue = error;
                 }
             });
-            result = await swarm$1.sessionPublicService.execute(content, "tool", METHOD_NAME$1J, clientId, swarmName);
+            result = await swarm$1.sessionPublicService.execute(content, "tool", METHOD_NAME$1K, clientId, swarmName);
             unError();
             if (errorValue) {
                 throw errorValue;
@@ -4775,26 +4775,26 @@ async function execute(content, clientId, agentName) {
 }
 
 /** @private Constant defining the method name for logging and validation context*/
-const METHOD_NAME$1I = "function.commit.commitFlush";
+const METHOD_NAME$1J = "function.commit.commitFlush";
 /**
  * Function implementation
 */
 const commitFlushInternal = beginContext(async (clientId, agentName) => {
     // Log the flush attempt if enabled
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$1I, {
+        swarm$1.loggerService.log(METHOD_NAME$1J, {
             clientId,
             agentName,
         });
     // Validate the agent exists
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1I);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1J);
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1I);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1J);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1I);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1J);
     // Check if the current agent matches the provided agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1I, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1J, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "commitFlush" skipped due to the agent change', {
@@ -4805,7 +4805,7 @@ const commitFlushInternal = beginContext(async (clientId, agentName) => {
         return;
     }
     // Commit the flush of agent history via SessionPublicService
-    await swarm$1.sessionPublicService.commitFlush(METHOD_NAME$1I, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitFlush(METHOD_NAME$1J, clientId, swarmName);
 });
 /**
  * Commits a flush of agent history for a specific client and agent in the swarm system.
@@ -4824,25 +4824,25 @@ async function commitFlush(clientId, agentName) {
     return await commitFlushInternal(clientId, agentName);
 }
 
-const METHOD_NAME$1H = "function.target.emit";
+const METHOD_NAME$1I = "function.target.emit";
 /**
  * Function implementation
 */
 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$1H, {
+        swarm$1.loggerService.log(METHOD_NAME$1I, {
             content,
             clientId,
             agentName,
         });
     // Validate the agent, session, and swarm
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1H);
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1H);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1I);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1I);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1H);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1I);
     // Check if the specified agent is still the active agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1H, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1I, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "emit" skipped due to the agent change', {
@@ -4853,7 +4853,7 @@ const emitInternal = beginContext(async (content, clientId, agentName) => {
         return;
     }
     // Emit the content directly via the session public service
-    return await swarm$1.sessionPublicService.emit(content, METHOD_NAME$1H, clientId, swarmName);
+    return await swarm$1.sessionPublicService.emit(content, METHOD_NAME$1I, clientId, swarmName);
 });
 /**
  * Emits a string as model output without executing an incoming message, with agent activity validation.
@@ -4875,22 +4875,22 @@ async function emit(content, clientId, agentName) {
     return await emitInternal(content, clientId, agentName);
 }
 
-const METHOD_NAME$1G = "function.common.getAgentName";
+const METHOD_NAME$1H = "function.common.getAgentName";
 /**
  * Function implementation
 */
 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$1G, {
+        swarm$1.loggerService.log(METHOD_NAME$1H, {
             clientId,
         });
     // Validate the session and swarm to ensure they exist and are accessible
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1G);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1H);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1G);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1H);
     // Retrieve the active agent name via the swarm public service
-    return await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1G, clientId, swarmName);
+    return await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1H, clientId, swarmName);
 });
 /**
  * Retrieves the name of the active agent for a given client session in a swarm.
@@ -4911,26 +4911,26 @@ async function getAgentName(clientId) {
 }
 
 /** @private Constant defining the method name for logging and validation context*/
-const METHOD_NAME$1F = "function.commit.commitStopTools";
+const METHOD_NAME$1G = "function.commit.commitStopTools";
 /**
  * Function implementation
 */
 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$1F, {
+        swarm$1.loggerService.log(METHOD_NAME$1G, {
             clientId,
             agentName,
         });
     // Validate the agent exists
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1F);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1G);
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1F);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1G);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1F);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1G);
     // Check if the current agent matches the provided agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1F, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1G, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "commitStopTools" skipped due to the agent change', {
@@ -4941,7 +4941,7 @@ const commitStopToolsInternal = beginContext(async (clientId, agentName) => {
         return;
     }
     // Commit the stop of the next tool execution via SessionPublicService
-    await swarm$1.sessionPublicService.commitStopTools(METHOD_NAME$1F, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitStopTools(METHOD_NAME$1G, clientId, swarmName);
 });
 /**
  * Prevents the next tool from being executed for a specific client and agent in the swarm system.
@@ -5455,12 +5455,12 @@ class AgentConnectionService {
 }
 
 /** @private Constant defining the method name for logging purposes*/
-const METHOD_NAME$1E = "function.common.getPayload";
+const METHOD_NAME$1F = "function.common.getPayload";
 /**
  * Function implementation
 */
 const getPayloadInternal = () => {
-    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$1E);
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$1F);
     if (PayloadContextService.hasContext()) {
         const { payload } = swarm$1.payloadContextService.context;
         return payload;
@@ -17094,14 +17094,14 @@ const swarm = {
 init();
 var swarm$1 = swarm;
 
-const METHOD_NAME$1D = "cli.dumpDocs";
+const METHOD_NAME$1E = "cli.dumpDocs";
 /**
  * Dumps the documentation for the agents and swarms.
  *
 */
 const dumpDocs = beginContext((prefix = "swarm", dirName = "./docs/chat", PlantUML, sanitizeMarkdown = (t) => t) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$1D, {
+        swarm$1.loggerService.log(METHOD_NAME$1E, {
             dirName,
         });
     if (PlantUML) {
@@ -17111,10 +17111,10 @@ const dumpDocs = beginContext((prefix = "swarm", dirName = "./docs/chat", PlantU
     }
     swarm$1.agentValidationService
         .getAgentList()
-        .forEach((agentName) => swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1D));
+        .forEach((agentName) => swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1E));
     swarm$1.swarmValidationService
         .getSwarmList()
-        .forEach((swarmName) => swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1D));
+        .forEach((swarmName) => swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1E));
     swarm$1.agentValidationService.getAgentList().forEach((agentName) => {
         const { dependsOn } = swarm$1.agentSchemaService.get(agentName);
         if (!dependsOn) {
@@ -17123,39 +17123,39 @@ const dumpDocs = beginContext((prefix = "swarm", dirName = "./docs/chat", PlantU
     });
     swarm$1.outlineValidationService
         .getOutlineList()
-        .forEach((swarmName) => swarm$1.outlineValidationService.validate(swarmName, METHOD_NAME$1D));
+        .forEach((swarmName) => swarm$1.outlineValidationService.validate(swarmName, METHOD_NAME$1E));
     return swarm$1.docService.dumpDocs(prefix, dirName, sanitizeMarkdown);
 });
 
-const METHOD_NAME$1C = "cli.dumpAgent";
+const METHOD_NAME$1D = "cli.dumpAgent";
 /**
  * Dumps the agent information into PlantUML format.
  *
 */
 const dumpAgent = beginContext((agentName, { withSubtree = false } = {}) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$1C, {
+        swarm$1.loggerService.log(METHOD_NAME$1D, {
             agentName,
         });
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1C);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1D);
     return swarm$1.agentMetaService.toUML(agentName, withSubtree);
 });
 
-const METHOD_NAME$1B = "cli.dumpSwarm";
+const METHOD_NAME$1C = "cli.dumpSwarm";
 /**
  * Dumps the swarm information into PlantUML format.
  *
 */
 const dumpSwarm = beginContext((swarmName) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$1B, {
+        swarm$1.loggerService.log(METHOD_NAME$1C, {
             swarmName,
         });
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1B);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1C);
     return swarm$1.swarmMetaService.toUML(swarmName);
 });
 
-const METHOD_NAME$1A = "cli.dumpPerfomance";
+const METHOD_NAME$1B = "cli.dumpPerfomance";
 const METHOD_NAME_INTERNAL$1 = "cli.dumpPerfomance.internal";
 const METHOD_NAME_INTERVAL = "cli.dumpPerfomance.interval";
 /**
@@ -17172,7 +17172,7 @@ const dumpPerfomanceInternal = beginContext(async (dirName = "./logs/meta") => {
  *
 */
 const dumpPerfomance = async (dirName = "./logs/meta") => {
-    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$1A);
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$1B);
     await dumpPerfomanceInternal(dirName);
 };
 /**
@@ -17224,7 +17224,7 @@ const listenExecutionEvent = beginContext((clientId, fn) => {
     return swarm$1.busService.subscribe(clientId, "execution-bus", functoolsKit.queued(async (e) => await fn(e)));
 });
 
-const METHOD_NAME$1z = "cli.dumpClientPerformance";
+const METHOD_NAME$1A = "cli.dumpClientPerformance";
 const METHOD_NAME_INTERNAL = "cli.dumpClientPerformance.internal";
 const METHOD_NAME_EXECUTE = "cli.dumpClientPerformance.execute";
 /**
@@ -17242,7 +17242,7 @@ const dumpClientPerformanceInternal = beginContext(async (clientId, dirName = ".
  *
 */
 const dumpClientPerformance = async (clientId, dirName = "./logs/client") => {
-    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$1z);
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$1A);
     await dumpClientPerformanceInternal(clientId, dirName);
 };
 /**
@@ -17368,24 +17368,24 @@ const dumpOutlineResult = beginContext(async (result, outputDir = "./dump/outlin
 });
 
 /** @private Constant defining the method name for logging and validation context*/
-const METHOD_NAME$1y = "function.commit.commitFlushForce";
+const METHOD_NAME$1z = "function.commit.commitFlushForce";
 /**
  * Function implementation
 */
 const commitFlushForceInternal = beginContext(async (clientId) => {
     // Log the flush attempt if enabled
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$1y, {
+        swarm$1.loggerService.log(METHOD_NAME$1z, {
             clientId,
-            METHOD_NAME: METHOD_NAME$1y,
+            METHOD_NAME: METHOD_NAME$1z,
         });
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1y);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1z);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1y);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1z);
     // Commit the flush of agent history via SessionPublicService without agent checks
-    await swarm$1.sessionPublicService.commitFlush(METHOD_NAME$1y, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitFlush(METHOD_NAME$1z, clientId, swarmName);
 });
 /**
  * Forcefully commits a flush of agent history for a specific client in the swarm system, without checking the active agent.
@@ -17404,24 +17404,24 @@ async function commitFlushForce(clientId) {
     return await commitFlushForceInternal(clientId);
 }
 
-const METHOD_NAME$1x = "function.commit.commitToolOutputForce";
+const METHOD_NAME$1y = "function.commit.commitToolOutputForce";
 /**
  * Function implementation
 */
 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$1x, {
+        swarm$1.loggerService.log(METHOD_NAME$1y, {
             toolId,
             content,
             clientId,
         });
     // Validate the session and swarm to ensure they exist and are accessible
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1x);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1y);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1x);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1y);
     // 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$1x, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitToolOutput(toolId, content, METHOD_NAME$1y, clientId, swarmName);
 });
 /**
  * Commits the output of a tool execution to the active agent in a swarm session without checking the active agent.
@@ -17446,15 +17446,15 @@ async function commitToolOutputForce(toolId, content, clientId) {
  * @private Constant defining the method name for logging and validation purposes.
  * Used as an identifier in log messages and validation checks to track calls to `hasNavigation`.
 */
-const METHOD_NAME$1w = "function.common.hasNavigation";
+const METHOD_NAME$1x = "function.common.hasNavigation";
 /**
  * Function implementation
 */
 const hasNavigationInternal = async (clientId, agentName) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$1w, { clientId });
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1w);
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1w);
+        swarm$1.loggerService.log(METHOD_NAME$1x, { clientId });
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1x);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1x);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     return swarm$1.navigationValidationService
         .getNavigationRoute(clientId, swarmName)
@@ -17471,14 +17471,14 @@ async function hasNavigation(clientId, agentName) {
     return await hasNavigationInternal(clientId, agentName);
 }
 
-const METHOD_NAME$1v = "function.history.getRawHistory";
+const METHOD_NAME$1w = "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$1v, {
+        swarm$1.loggerService.log(METHOD_NAME$1w, {
             clientId,
         });
     // Validate the session and swarm
@@ -17506,21 +17506,21 @@ const getRawHistoryInternal = beginContext(async (clientId, methodName) => {
  * console.log(rawHistory); // Outputs the full raw history array
 */
 async function getRawHistory(clientId) {
-    return await getRawHistoryInternal(clientId, METHOD_NAME$1v);
+    return await getRawHistoryInternal(clientId, METHOD_NAME$1w);
 }
 
-const METHOD_NAME$1u = "function.history.getLastUserMessage";
+const METHOD_NAME$1v = "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$1u, {
+        swarm$1.loggerService.log(METHOD_NAME$1v, {
             clientId,
         });
     // Fetch raw history and find the last user message
-    const history = await getRawHistoryInternal(clientId, METHOD_NAME$1u);
+    const history = await getRawHistoryInternal(clientId, METHOD_NAME$1v);
     const last = history.findLast(({ role, mode }) => role === "user" && mode === "user");
     return last?.content ? last.content : null;
 });
@@ -17542,7 +17542,7 @@ async function getLastUserMessage(clientId) {
     return await getLastUserMessageInternal(clientId);
 }
 
-const METHOD_NAME$1t = "function.navigate.changeToDefaultAgent";
+const METHOD_NAME$1u = "function.navigate.changeToDefaultAgent";
 /**
  * Creates a change agent function with time-to-live (TTL) and queuing capabilities for switching to the default agent.
  *
@@ -17563,7 +17563,7 @@ const createChangeToDefaultAgent = functoolsKit.memoize(([clientId]) => `${clien
     }));
     {
         // Dispose of the current agent's resources and set up the new default agent
-        const agentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1t, clientId, swarmName);
+        const agentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1u, clientId, swarmName);
         await swarm$1.agentPublicService.dispose(methodName, clientId, agentName);
         await swarm$1.historyPublicService.dispose(methodName, clientId, agentName);
         await swarm$1.swarmPublicService.setAgentRef(methodName, clientId, swarmName, agentName, await swarm$1.agentPublicService.createAgentRef(methodName, clientId, agentName));
@@ -17590,20 +17590,20 @@ const createGc$3 = functoolsKit.singleshot(async () => {
 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$1t, {
+        swarm$1.loggerService.log(METHOD_NAME$1u, {
             clientId,
         });
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     const { defaultAgent: agentName } = swarm$1.swarmSchemaService.get(swarmName);
     {
         // Validate session and default agent
-        swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1t);
-        swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1t);
+        swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1u);
+        swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1u);
     }
     // Execute the agent change with TTL and queuing
     const run = await createChangeToDefaultAgent(clientId);
     createGc$3();
-    return await run(METHOD_NAME$1t, agentName, swarmName);
+    return await run(METHOD_NAME$1u, agentName, swarmName);
 });
 /**
  * Navigates back to the default agent for a given client session in a swarm.
@@ -17622,23 +17622,23 @@ async function changeToDefaultAgent(clientId) {
     return await changeToDefaultAgentInternal(clientId);
 }
 
-const METHOD_NAME$1s = "function.target.emitForce";
+const METHOD_NAME$1t = "function.target.emitForce";
 /**
  * Function implementation
 */
 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$1s, {
+        swarm$1.loggerService.log(METHOD_NAME$1t, {
             content,
             clientId,
         });
     // Validate the session and swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1s);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1t);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1s);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1t);
     // Emit the content directly via the session public service
-    return await swarm$1.sessionPublicService.emit(content, METHOD_NAME$1s, clientId, swarmName);
+    return await swarm$1.sessionPublicService.emit(content, METHOD_NAME$1t, clientId, swarmName);
 });
 /**
  * Emits a string as model output without executing an incoming message or checking the active agent.
@@ -17659,7 +17659,7 @@ async function emitForce(content, clientId) {
     return await emitForceInternal(content, clientId);
 }
 
-const METHOD_NAME$1r = "function.target.executeForce";
+const METHOD_NAME$1s = "function.target.executeForce";
 /**
  * Function implementation
 */
@@ -17667,15 +17667,15 @@ 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 &&
-        swarm$1.loggerService.log(METHOD_NAME$1r, {
+        swarm$1.loggerService.log(METHOD_NAME$1s, {
             content,
             clientId,
             executionId,
         });
     // Validate the session and swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1r);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1s);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1r);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1s);
     // Execute the command within an execution context with performance tracking
     return ExecutionContextService.runInContext(async () => {
         let isFinished = false;
@@ -17689,7 +17689,7 @@ const executeForceInternal = beginContext(async (content, clientId) => {
                     errorValue = error;
                 }
             });
-            result = await swarm$1.sessionPublicService.execute(content, "tool", METHOD_NAME$1r, clientId, swarmName);
+            result = await swarm$1.sessionPublicService.execute(content, "tool", METHOD_NAME$1s, clientId, swarmName);
             unError();
             if (errorValue) {
                 throw errorValue;
@@ -17731,24 +17731,24 @@ async function executeForce(content, clientId) {
 }
 
 /** @private Constant defining the method name for logging and validation context*/
-const METHOD_NAME$1q = "function.commit.commitStopToolsForce";
+const METHOD_NAME$1r = "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$1q, {
+        swarm$1.loggerService.log(METHOD_NAME$1r, {
             clientId,
-            METHOD_NAME: METHOD_NAME$1q,
+            METHOD_NAME: METHOD_NAME$1r,
         });
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1q);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1r);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1q);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1r);
     // Commit the stop of the next tool execution via SessionPublicService without agent checks
-    await swarm$1.sessionPublicService.commitStopTools(METHOD_NAME$1q, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitStopTools(METHOD_NAME$1r, clientId, swarmName);
 });
 /**
  * Forcefully prevents the next tool from being executed for a specific client in the swarm system, without checking the active agent.
@@ -17767,7 +17767,7 @@ async function commitStopToolsForce(clientId) {
     return await commitStopToolsForceInternal(clientId);
 }
 
-const METHOD_NAME$1p = "function.template.navigateToTriageAgent";
+const METHOD_NAME$1q = "function.template.navigateToTriageAgent";
 /**
  * Will send tool output directly to the model without any additions
 */
@@ -17809,7 +17809,7 @@ const createNavigateToTriageAgent = ({ flushMessage, beforeNavigate, lastMessage
      */
     return beginContext(async (toolId, clientId) => {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-            swarm$1.loggerService.log(METHOD_NAME$1p, {
+            swarm$1.loggerService.log(METHOD_NAME$1q, {
                 clientId,
                 toolId,
             });
@@ -17844,7 +17844,7 @@ const createNavigateToTriageAgent = ({ flushMessage, beforeNavigate, lastMessage
     });
 };
 
-const METHOD_NAME$1o = "function.navigate.changeToAgent";
+const METHOD_NAME$1p = "function.navigate.changeToAgent";
 /**
  * Creates a change agent function with time-to-live (TTL) and queuing capabilities.
  *
@@ -17866,7 +17866,7 @@ const createChangeToAgent = functoolsKit.memoize(([clientId]) => `${clientId}`,
     }));
     {
         // Dispose of the current agent's resources and set up the new agent
-        const agentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1o, clientId, swarmName);
+        const agentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1p, clientId, swarmName);
         await swarm$1.agentPublicService.dispose(methodName, clientId, agentName);
         await swarm$1.historyPublicService.dispose(methodName, clientId, agentName);
         await swarm$1.swarmPublicService.setAgentRef(methodName, clientId, swarmName, agentName, await swarm$1.agentPublicService.createAgentRef(methodName, clientId, agentName));
@@ -17893,16 +17893,16 @@ const createGc$2 = functoolsKit.singleshot(async () => {
 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$1o, {
+        swarm$1.loggerService.log(METHOD_NAME$1p, {
             agentName,
             clientId,
         });
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     {
         // Validate session, agent, and dependencies
-        swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1o);
-        swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1o);
-        const activeAgent = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1o, clientId, swarmName);
+        swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1p);
+        swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1p);
+        const activeAgent = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1p, clientId, swarmName);
         if (!swarm$1.agentValidationService.hasDependency(activeAgent, agentName)) {
             console.error(`agent-swarm missing dependency detected for activeAgent=${activeAgent} dependencyAgent=${agentName}`);
         }
@@ -17920,7 +17920,7 @@ const changeToAgentInternal = beginContext(async (agentName, clientId) => {
     // Execute the agent change with TTL and queuing
     const run = await createChangeToAgent(clientId);
     createGc$2();
-    return await run(METHOD_NAME$1o, agentName, swarmName);
+    return await run(METHOD_NAME$1p, agentName, swarmName);
 });
 /**
  * Changes the active agent for a given client session in a swarm.
@@ -17940,7 +17940,7 @@ async function changeToAgent(agentName, clientId) {
     return await changeToAgentInternal(agentName, clientId);
 }
 
-const METHOD_NAME$1n = "function.template.navigateToAgent";
+const METHOD_NAME$1o = "function.template.navigateToAgent";
 /**
  * Will send tool output directly to the model without any additions
 */
@@ -17996,7 +17996,7 @@ const createNavigateToAgent = ({ beforeNavigate, lastMessage: lastMessageFn = DE
      */
     return beginContext(async (toolId, clientId, agentName) => {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-            swarm$1.loggerService.log(METHOD_NAME$1n, {
+            swarm$1.loggerService.log(METHOD_NAME$1o, {
                 clientId,
                 toolId,
             });
@@ -18034,7 +18034,7 @@ const createNavigateToAgent = ({ beforeNavigate, lastMessage: lastMessageFn = DE
     });
 };
 
-const METHOD_NAME$1m = "function.template.commitAction";
+const METHOD_NAME$1n = "function.template.commitAction";
 /**
  * Creates a commit action handler that executes actions and modifies system state (WRITE pattern).
  *
@@ -18083,7 +18083,7 @@ const createCommitAction = ({ validateParams, executeAction, emptyContent, fallb
     return beginContext(async (toolId, clientId, agentName, toolName, params, toolCalls, isLast) => {
         let executeMessage = "";
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-            swarm$1.loggerService.log(METHOD_NAME$1m, {
+            swarm$1.loggerService.log(METHOD_NAME$1n, {
                 clientId,
                 toolId,
                 agentName,
@@ -18177,7 +18177,7 @@ const createCommitAction = ({ validateParams, executeAction, emptyContent, fallb
     });
 };
 
-const METHOD_NAME$1l = "function.template.fetchInfo";
+const METHOD_NAME$1m = "function.template.fetchInfo";
 /**
  * Default message when content is empty.
  */
@@ -18223,7 +18223,7 @@ const createFetchInfo = ({ fetchContent, fallback, emptyContent = DEFAULT_EMPTY_
     return beginContext(async (toolId, clientId, agentName, toolName, params, isLast) => {
         let executeMessage = "";
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-            swarm$1.loggerService.log(METHOD_NAME$1l, {
+            swarm$1.loggerService.log(METHOD_NAME$1m, {
                 clientId,
                 toolId,
                 agentName,
@@ -18234,7 +18234,7 @@ const createFetchInfo = ({ fetchContent, fallback, emptyContent = DEFAULT_EMPTY_
         const currentAgentName = await getAgentName(clientId);
         if (currentAgentName !== agentName) {
             GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                swarm$1.loggerService.log(`${METHOD_NAME$1l} skipped due to agent change`, {
+                swarm$1.loggerService.log(`${METHOD_NAME$1m} skipped due to agent change`, {
                     currentAgentName,
                     agentName,
                     clientId,
@@ -18269,14 +18269,14 @@ const createFetchInfo = ({ fetchContent, fallback, emptyContent = DEFAULT_EMPTY_
     });
 };
 
-const METHOD_NAME$1k = "function.setup.addTool";
+const METHOD_NAME$1l = "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$1k, {
+        swarm$1.loggerService.log(METHOD_NAME$1l, {
             toolSchema,
         });
     // Register the tool in the validation and schema services
@@ -18310,12 +18310,12 @@ function addTool(toolSchema) {
  * Adds navigation functionality to an agent by creating a tool that allows navigation to a specified agent.
  * @module addAgentNavigation
 */
-const METHOD_NAME$1j = "function.alias.addAgentNavigation";
+const METHOD_NAME$1k = "function.alias.addAgentNavigation";
 /**
  * Function implementation
 */
 const addAgentNavigationInternal = beginContext(({ toolName, docNote, description, navigateTo, isAvailable, ...navigateProps }) => {
-    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$1j);
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$1k);
     const navigate = createNavigateToAgent(navigateProps);
     const toolSchema = addTool({
         toolName,
@@ -18354,12 +18354,12 @@ function addAgentNavigation(params) {
  * Adds triage navigation functionality to an agent by creating a tool that facilitates navigation to a triage agent.
  * @module addTriageNavigation
 */
-const METHOD_NAME$1i = "function.alias.addTriageNavigation";
+const METHOD_NAME$1j = "function.alias.addTriageNavigation";
 /**
  * Function implementation
 */
 const addTriageNavigationInternal = beginContext(({ toolName, docNote, description, isAvailable, ...navigateProps }) => {
-    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$1i);
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$1j);
     const navigate = createNavigateToTriageAgent(navigateProps);
     const toolSchema = addTool({
         toolName,
@@ -18398,12 +18398,12 @@ function addTriageNavigation(params) {
  * Adds commit action functionality to an agent by creating a tool that validates and executes actions.
  * @module addCommitAction
  */
-const METHOD_NAME$1h = "function.alias.addCommitAction";
+const METHOD_NAME$1i = "function.alias.addCommitAction";
 /**
  * Function implementation
  */
 const addCommitActionInternal = beginContext(({ toolName, docNote, function: functionSchema, isAvailable, ...actionProps }) => {
-    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$1h);
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$1i);
     const action = createCommitAction(actionProps);
     const toolSchema = addTool({
         toolName,
@@ -18480,12 +18480,12 @@ function addCommitAction(params) {
  * Adds fetch info functionality to an agent by creating a tool that fetches and provides information.
  * @module addFetchInfo
  */
-const METHOD_NAME$1g = "function.alias.addFetchInfo";
+const METHOD_NAME$1h = "function.alias.addFetchInfo";
 /**
  * Function implementation
  */
 const addFetchInfoInternal = beginContext(({ toolName, docNote, function: functionSchema, isAvailable, validateParams: validate, ...fetchProps }) => {
-    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$1g);
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$1h);
     const fetch = createFetchInfo(fetchProps);
     const toolSchema = addTool({
         toolName,
@@ -18551,13 +18551,13 @@ function addFetchInfo(params) {
 }
 
 /** @constant {string} METHOD_NAME - The name of the method used for logging*/
-const METHOD_NAME$1f = "function.setup.addAdvisor";
+const METHOD_NAME$1g = "function.setup.addAdvisor";
 /**
  * Function implementation
 */
 const addAdvisorInternal = beginContext((advisorSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$1f, {
+        swarm$1.loggerService.log(METHOD_NAME$1g, {
             advisorSchema,
         });
     swarm$1.advisorValidationService.addAdvisor(advisorSchema.advisorName, advisorSchema);
@@ -18668,14 +18668,14 @@ const mapAgentSchema = ({ system, systemDynamic, systemStatic, ...schema }) => r
         : systemDynamic,
 });
 
-const METHOD_NAME$1e = "function.setup.addAgent";
+const METHOD_NAME$1f = "function.setup.addAgent";
 /**
  * Function implementation
 */
 const addAgentInternal = beginContext((publicAgentSchema) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$1e, {
+        swarm$1.loggerService.log(METHOD_NAME$1f, {
             agentSchema: publicAgentSchema,
         });
     const agentSchema = mapAgentSchema(publicAgentSchema);
@@ -18714,27 +18714,19 @@ function addAgent(agentSchema) {
 const mapCompletionSchema = ({ getCompletion, ...schema }) => removeUndefined({
     ...schema,
     getCompletion: getCompletion
-        ? async ({ mode, messages, agentName, clientId, format, outlineName, tools, }) => {
-            const params = {
-                mode,
-                messages,
-                agentName,
-                clientId,
-                format,
-                outlineName,
-                tools,
-            };
+        ? async (args) => {
             try {
-                return await getCompletion(params);
+                return await getCompletion(args);
             }
             catch (error) {
-                if (clientId) {
-                    errorSubject.next([clientId, error]);
+                if ("clientId" in args && args.clientId) {
+                    errorSubject.next([args.clientId, error]);
                 }
                 return {
-                    agentName,
+                    error: functoolsKit.getErrorMessage(error),
+                    agentName: ("agentName" in args && args.agentName) || "",
                     content: "",
-                    mode,
+                    mode: ("mode" in args && args.mode) || "",
                     role: "assistant",
                 };
             }
@@ -18742,14 +18734,14 @@ const mapCompletionSchema = ({ getCompletion, ...schema }) => removeUndefined({
         : undefined,
 });
 
-const METHOD_NAME$1d = "function.setup.addCompletion";
+const METHOD_NAME$1e = "function.setup.addCompletion";
 /**
  * Function implementation
 */
 const addCompletionInternal = beginContext((completionPublicSchema) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$1d, {
+        swarm$1.loggerService.log(METHOD_NAME$1e, {
             completionSchema: completionPublicSchema,
         });
     const completionSchema = mapCompletionSchema(completionPublicSchema);
@@ -18779,14 +18771,14 @@ function addCompletion(completionSchema) {
     return addCompletionInternal(completionSchema);
 }
 
-const METHOD_NAME$1c = "function.setup.addSwarm";
+const METHOD_NAME$1d = "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$1c, {
+        swarm$1.loggerService.log(METHOD_NAME$1d, {
             swarmSchema,
         });
     // Register the swarm in the validation and schema services
@@ -18815,13 +18807,13 @@ function addSwarm(swarmSchema) {
     return addSwarmInternal(swarmSchema);
 }
 
-const METHOD_NAME$1b = "function.setup.addMCP";
+const METHOD_NAME$1c = "function.setup.addMCP";
 /**
  * Function implementation
 */
 const addMCPInternal = beginContext((mcpSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$1b, {
+        swarm$1.loggerService.log(METHOD_NAME$1c, {
             mcpSchema,
         });
     swarm$1.mcpValidationService.addMCP(mcpSchema.mcpName, mcpSchema);
@@ -18836,14 +18828,14 @@ function addMCP(mcpSchema) {
     return addMCPInternal(mcpSchema);
 }
 
-const METHOD_NAME$1a = "function.setup.addState";
+const METHOD_NAME$1b = "function.setup.addState";
 /**
  * Function implementation
 */
 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$1a, {
+        swarm$1.loggerService.log(METHOD_NAME$1b, {
             stateSchema,
         });
     // Register the policy with StateValidationService for runtime validation
@@ -18881,14 +18873,14 @@ function addState(stateSchema) {
     return addStateInternal(stateSchema);
 }
 
-const METHOD_NAME$19 = "function.setup.addEmbedding";
+const METHOD_NAME$1a = "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$19, {
+        swarm$1.loggerService.log(METHOD_NAME$1a, {
             embeddingSchema,
         });
     // Register the embedding in the validation and schema services
@@ -18917,14 +18909,14 @@ function addEmbedding(embeddingSchema) {
     return addEmbeddingInternal(embeddingSchema);
 }
 
-const METHOD_NAME$18 = "function.setup.addStorage";
+const METHOD_NAME$19 = "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$18, {
+        swarm$1.loggerService.log(METHOD_NAME$19, {
             storageSchema,
         });
     // Register the storage in the validation and schema services
@@ -18962,14 +18954,14 @@ function addStorage(storageSchema) {
 }
 
 /** @private Constant defining the method name for logging and validation context*/
-const METHOD_NAME$17 = "function.setup.addPolicy";
+const METHOD_NAME$18 = "function.setup.addPolicy";
 /**
  * Function implementation
 */
 const addPolicyInternal = beginContext((policySchema) => {
     // Log the policy addition attempt if enabled
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$17, {
+        swarm$1.loggerService.log(METHOD_NAME$18, {
             policySchema,
         });
     // Register the policy with PolicyValidationService for runtime validation
@@ -19030,13 +19022,13 @@ function addCompute(computeSchema) {
  * Method name for the addPipeline operation.
  * @private
 */
-const METHOD_NAME$16 = "function.setup.addPipeline";
+const METHOD_NAME$17 = "function.setup.addPipeline";
 /**
  * Function implementation
 */
 const addPipelineInternal = beginContext((pipelineSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$16, {
+        swarm$1.loggerService.log(METHOD_NAME$17, {
             pipelineSchema,
         });
     swarm$1.pipelineValidationService.addPipeline(pipelineSchema.pipelineName, pipelineSchema);
@@ -19059,7 +19051,7 @@ function addPipeline(pipelineSchema) {
  * @private
  * @constant {string}
 */
-const METHOD_NAME$15 = "function.setup.addOutline";
+const METHOD_NAME$16 = "function.setup.addOutline";
 /**
  * Internal implementation of the outline addition logic, wrapped in a clean context.
  * Registers the outline schema with both the validation and schema services and logs the operation if enabled.
@@ -19067,7 +19059,7 @@ const METHOD_NAME$15 = "function.setup.addOutline";
 */
 const addOutlineInternal = beginContext((outlineSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$15, {
+        swarm$1.loggerService.log(METHOD_NAME$16, {
             outlineSchema,
         });
     swarm$1.outlineValidationService.addOutline(outlineSchema.outlineName, outlineSchema);
@@ -19086,13 +19078,13 @@ function addOutline(outlineSchema) {
     return addOutlineInternal(outlineSchema);
 }
 
-const METHOD_NAME$14 = "function.test.overrideAgent";
+const METHOD_NAME$15 = "function.test.overrideAgent";
 /**
  * Function implementation
 */
 const overrideAgentInternal = beginContext((publicAgentSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$14, {
+        swarm$1.loggerService.log(METHOD_NAME$15, {
             agentSchema: publicAgentSchema,
         });
     const agentSchema = mapAgentSchema(publicAgentSchema);
@@ -19121,13 +19113,13 @@ function overrideAgent(agentSchema) {
     return overrideAgentInternal(agentSchema);
 }
 
-const METHOD_NAME$13 = "function.test.overrideCompletion";
+const METHOD_NAME$14 = "function.test.overrideCompletion";
 /**
  * Function implementation
 */
 const overrideCompletionInternal = beginContext((publicCompletionSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$13, {
+        swarm$1.loggerService.log(METHOD_NAME$14, {
             completionSchema: publicCompletionSchema,
         });
     const completionSchema = mapCompletionSchema(publicCompletionSchema);
@@ -19156,13 +19148,13 @@ function overrideCompletion(completionSchema) {
     return overrideCompletionInternal(completionSchema);
 }
 
-const METHOD_NAME$12 = "function.test.overrideEmbeding";
+const METHOD_NAME$13 = "function.test.overrideEmbeding";
 /**
  * Function implementation
 */
 const overrideEmbedingInternal = beginContext((publicEmbeddingSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$12, {
+        swarm$1.loggerService.log(METHOD_NAME$13, {
             embeddingSchema: publicEmbeddingSchema,
         });
     const embeddingSchema = removeUndefined(publicEmbeddingSchema);
@@ -19193,13 +19185,13 @@ function overrideEmbeding(embeddingSchema) {
     return overrideEmbedingInternal(embeddingSchema);
 }
 
-const METHOD_NAME$11 = "function.test.overridePolicy";
+const METHOD_NAME$12 = "function.test.overridePolicy";
 /**
  * Function implementation
 */
 const overridePolicyInternal = beginContext((publicPolicySchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$11, {
+        swarm$1.loggerService.log(METHOD_NAME$12, {
             policySchema: publicPolicySchema,
         });
     const policySchema = removeUndefined(publicPolicySchema);
@@ -19228,13 +19220,13 @@ function overridePolicy(policySchema) {
     return overridePolicyInternal(policySchema);
 }
 
-const METHOD_NAME$10 = "function.test.overrideState";
+const METHOD_NAME$11 = "function.test.overrideState";
 /**
  * Function implementation
 */
 const overrideStateInternal = beginContext((publicStateSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$10, {
+        swarm$1.loggerService.log(METHOD_NAME$11, {
             stateSchema: publicStateSchema,
         });
     const stateSchema = removeUndefined(publicStateSchema);
@@ -19264,13 +19256,13 @@ function overrideState(stateSchema) {
     return overrideStateInternal(stateSchema);
 }
 
-const METHOD_NAME$$ = "function.test.overrideStorage";
+const METHOD_NAME$10 = "function.test.overrideStorage";
 /**
  * Function implementation
 */
 const overrideStorageInternal = beginContext((publicStorageSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$$, {
+        swarm$1.loggerService.log(METHOD_NAME$10, {
             storageSchema: publicStorageSchema,
         });
     const storageSchema = removeUndefined(publicStorageSchema);
@@ -19301,13 +19293,13 @@ function overrideStorage(storageSchema) {
     return overrideStorageInternal(storageSchema);
 }
 
-const METHOD_NAME$_ = "function.test.overrideSwarm";
+const METHOD_NAME$$ = "function.test.overrideSwarm";
 /**
  * Function implementation
 */
 const overrideSwarmInternal = beginContext((publicSwarmSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$_, {
+        swarm$1.loggerService.log(METHOD_NAME$$, {
             swarmSchema: publicSwarmSchema,
         });
     const swarmSchema = removeUndefined(publicSwarmSchema);
@@ -19336,13 +19328,13 @@ function overrideSwarm(swarmSchema) {
     return overrideSwarmInternal(swarmSchema);
 }
 
-const METHOD_NAME$Z = "function.test.overrideTool";
+const METHOD_NAME$_ = "function.test.overrideTool";
 /**
  * Function implementation
 */
 const overrideToolInternal = beginContext((publicToolSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$Z, {
+        swarm$1.loggerService.log(METHOD_NAME$_, {
             toolSchema: publicToolSchema,
         });
     const toolSchema = removeUndefined(publicToolSchema);
@@ -19370,13 +19362,13 @@ function overrideTool(toolSchema) {
     return overrideToolInternal(toolSchema);
 }
 
-const METHOD_NAME$Y = "function.test.overrideMCP";
+const METHOD_NAME$Z = "function.test.overrideMCP";
 /**
  * Function implementation
 */
 const overrideMCPInternal = beginContext((publicMcpSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$Y, {
+        swarm$1.loggerService.log(METHOD_NAME$Z, {
             mcpSchema: publicMcpSchema,
         });
     const mcpSchema = removeUndefined(publicMcpSchema);
@@ -19390,13 +19382,13 @@ function overrideMCP(mcpSchema) {
     return overrideMCPInternal(mcpSchema);
 }
 
-const METHOD_NAME$X = "function.test.overrideAdvisor";
+const METHOD_NAME$Y = "function.test.overrideAdvisor";
 /**
  * Function implementation
  */
 const overrideAdvisorInternal = beginContext((publicAdvisorSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$X, {
+        swarm$1.loggerService.log(METHOD_NAME$Y, {
             advisorSchema: publicAdvisorSchema,
         });
     const advisorSchema = removeUndefined(publicAdvisorSchema);
@@ -19443,13 +19435,13 @@ function overrideAdvisor(advisorSchema) {
  * Method name for the overrideCompute operation.
  * @private
 */
-const METHOD_NAME$W = "function.test.overrideCompute";
+const METHOD_NAME$X = "function.test.overrideCompute";
 /**
  * Function implementation
 */
 const overrideComputeInternal = beginContext((publicComputeSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$W, {
+        swarm$1.loggerService.log(METHOD_NAME$X, {
             computeSchema: publicComputeSchema,
         });
     const computeSchema = removeUndefined(publicComputeSchema);
@@ -19473,13 +19465,13 @@ function overrideCompute(computeSchema) {
  * Method name for the overridePipeline operation.
  * @private
 */
-const METHOD_NAME$V = "function.test.overridePipeline";
+const METHOD_NAME$W = "function.test.overridePipeline";
 /**
  * Function implementation
 */
 const overridePipelineInternal = beginContext((publicPipelineSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$V, {
+        swarm$1.loggerService.log(METHOD_NAME$W, {
             pipelineSchema: publicPipelineSchema,
         });
     const pipelineSchema = removeUndefined(publicPipelineSchema);
@@ -19501,7 +19493,7 @@ function overridePipeline(pipelineSchema) {
  * @private
  * @constant {string}
 */
-const METHOD_NAME$U = "function.test.overrideOutline";
+const METHOD_NAME$V = "function.test.overrideOutline";
 /**
  * Internal implementation of the outline override logic, wrapped in a clean context.
  * Updates the specified outline schema in the swarm's schema service and logs the operation if enabled.
@@ -19509,7 +19501,7 @@ const METHOD_NAME$U = "function.test.overrideOutline";
 */
 const overrideOutlineInternal = beginContext((publicOutlineSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$U, {
+        swarm$1.loggerService.log(METHOD_NAME$V, {
             outlineSchema: publicOutlineSchema,
         });
     const outlineSchema = removeUndefined(publicOutlineSchema);
@@ -19527,23 +19519,23 @@ function overrideOutline(outlineSchema) {
     return overrideOutlineInternal(outlineSchema);
 }
 
-const METHOD_NAME$T = "function.other.markOnline";
+const METHOD_NAME$U = "function.other.markOnline";
 /**
  * Function implementation
 */
 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$T, {
+        swarm.loggerService.log(METHOD_NAME$U, {
             clientId,
         });
     // Validate the swarm name
-    swarm.swarmValidationService.validate(swarmName, METHOD_NAME$T);
+    swarm.swarmValidationService.validate(swarmName, METHOD_NAME$U);
     // Run the operation in the method context
     return await MethodContextService.runInContext(async () => {
-        await swarm.aliveService.markOnline(clientId, swarmName, METHOD_NAME$T);
+        await swarm.aliveService.markOnline(clientId, swarmName, METHOD_NAME$U);
     }, {
-        methodName: METHOD_NAME$T,
+        methodName: METHOD_NAME$U,
         agentName: "",
         policyName: "",
         stateName: "",
@@ -19566,20 +19558,20 @@ async function markOnline(clientId, swarmName) {
     return await markOnlineInternal(clientId, swarmName);
 }
 
-const METHOD_NAME$S = "function.other.markOffline";
+const METHOD_NAME$T = "function.other.markOffline";
 /**
  * Function implementation
 */
 const markOfflineInternal = async (clientId, swarmName) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm.loggerService.log(METHOD_NAME$S, {
+        swarm.loggerService.log(METHOD_NAME$T, {
             clientId,
         });
-    swarm.swarmValidationService.validate(swarmName, METHOD_NAME$S);
+    swarm.swarmValidationService.validate(swarmName, METHOD_NAME$T);
     return await MethodContextService.runInContext(async () => {
-        await swarm.aliveService.markOffline(clientId, swarmName, METHOD_NAME$S);
+        await swarm.aliveService.markOffline(clientId, swarmName, METHOD_NAME$T);
     }, {
-        methodName: METHOD_NAME$S,
+        methodName: METHOD_NAME$T,
         agentName: "",
         policyName: "",
         stateName: "",
@@ -19607,27 +19599,27 @@ async function markOffline(clientId, swarmName) {
 }
 
 /** @private Constant defining the method name for logging and validation context*/
-const METHOD_NAME$R = "function.commit.commitSystemMessage";
+const METHOD_NAME$S = "function.commit.commitSystemMessage";
 /**
  * Function implementation
 */
 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$R, {
+        swarm$1.loggerService.log(METHOD_NAME$S, {
             content,
             clientId,
             agentName,
         });
     // Validate the agent exists
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$R);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$S);
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$R);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$S);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$R);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$S);
     // Check if the current agent matches the provided agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$R, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$S, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "commitSystemMessage" skipped due to the agent change', {
@@ -19638,7 +19630,7 @@ const commitSystemMessageInternal = beginContext(async (content, clientId, agent
         return;
     }
     // Commit the system message via SessionPublicService
-    await swarm$1.sessionPublicService.commitSystemMessage(content, METHOD_NAME$R, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitSystemMessage(content, METHOD_NAME$S, clientId, swarmName);
 });
 /**
  * Commits a system-generated message to the active agent in the swarm system.
@@ -19660,22 +19652,22 @@ async function commitSystemMessage(content, clientId, agentName) {
 }
 
 /** @private Constant defining the method name for logging and validation context*/
-const METHOD_NAME$Q = "function.commit.commitDeveloperMessage";
+const METHOD_NAME$R = "function.commit.commitDeveloperMessage";
 /**
  * Function implementation
 */
 const commitDeveloperMessageInternal = beginContext(async (content, clientId, agentName) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$Q, {
+        swarm$1.loggerService.log(METHOD_NAME$R, {
             content,
             clientId,
             agentName,
         });
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$Q);
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$Q);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$R);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$R);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$Q);
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$Q, clientId, swarmName);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$R);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$R, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "commitDeveloperMessage" skipped due to the agent change', {
@@ -19685,7 +19677,7 @@ const commitDeveloperMessageInternal = beginContext(async (content, clientId, ag
             });
         return;
     }
-    await swarm$1.sessionPublicService.commitDeveloperMessage(content, METHOD_NAME$Q, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitDeveloperMessage(content, METHOD_NAME$R, clientId, swarmName);
 });
 /**
  * Commits a developer-generated message to the active agent in the swarm system.
@@ -19706,26 +19698,26 @@ async function commitDeveloperMessage(content, clientId, agentName) {
     return await commitDeveloperMessageInternal(content, clientId, agentName);
 }
 
-const METHOD_NAME$P = "function.commit.commitSystemMessage";
+const METHOD_NAME$Q = "function.commit.commitSystemMessage";
 /**
  * Function implementation
 */
 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$P, {
+        swarm$1.loggerService.log(METHOD_NAME$Q, {
             content,
             clientId,
             agentName,
             mode,
         });
     // Validate the agent, session, and swarm to ensure they exist and are accessible
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$P);
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$P);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$Q);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$Q);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$P);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$Q);
     // Check if the specified agent is still the active agent in the swarm session
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$P, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$Q, clientId, swarmName);
     if (currentAgentName !== agentName) {
         // Log a skip message if the agent has changed during the operation
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
@@ -19738,14 +19730,14 @@ const commitUserMessageInternal = beginContext(async (content, mode, clientId, a
     }
     if (payload) {
         return await PayloadContextService.runInContext(async () => {
-            await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$P, clientId, swarmName);
+            await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$Q, clientId, swarmName);
         }, {
             clientId,
             payload,
         });
     }
     // Commit the user message to the agent's history via the session public service
-    return await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$P, clientId, swarmName);
+    return await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$Q, clientId, swarmName);
 });
 /**
  * Commits a user message to the active agent's history in a swarm session without triggering a response.
@@ -19769,24 +19761,24 @@ async function commitUserMessage(content, mode, clientId, agentName, payload) {
 }
 
 /** @private Constant defining the method name for logging and validation context*/
-const METHOD_NAME$O = "function.commit.commitSystemMessageForce";
+const METHOD_NAME$P = "function.commit.commitSystemMessageForce";
 /**
  * Function implementation
 */
 const commitSystemMessageForceInternal = beginContext(async (content, clientId) => {
     // Log the commit attempt if enabled
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$O, {
+        swarm$1.loggerService.log(METHOD_NAME$P, {
             content,
             clientId,
         });
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$O);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$P);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$O);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$P);
     // Commit the system message via SessionPublicService without agent checks
-    await swarm$1.sessionPublicService.commitSystemMessage(content, METHOD_NAME$O, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitSystemMessage(content, METHOD_NAME$P, clientId, swarmName);
 });
 /**
  * Forcefully commits a system-generated message to a session in the swarm system, without checking the active agent.
@@ -19807,7 +19799,7 @@ async function commitSystemMessageForce(content, clientId) {
 }
 
 /** @private Constant defining the method name for logging and validation context*/
-const METHOD_NAME$N = "function.commit.commitDeveloperMessageForce";
+const METHOD_NAME$O = "function.commit.commitDeveloperMessageForce";
 /**
  * Internal implementation for forcefully committing a developer message to a session in the swarm system.
  * Logs the operation if enabled, validates the session and swarm, and commits the message via SessionPublicService.
@@ -19820,14 +19812,14 @@ const METHOD_NAME$N = "function.commit.commitDeveloperMessageForce";
 */
 const commitDeveloperMessageForceInternal = beginContext(async (content, clientId) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$N, {
+        swarm$1.loggerService.log(METHOD_NAME$O, {
             content,
             clientId,
         });
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$N);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$O);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$N);
-    await swarm$1.sessionPublicService.commitDeveloperMessage(content, METHOD_NAME$N, clientId, swarmName);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$O);
+    await swarm$1.sessionPublicService.commitDeveloperMessage(content, METHOD_NAME$O, clientId, swarmName);
 });
 /**
  * Forcefully commits a developer-generated message to a session in the swarm system, without checking the active agent.
@@ -19846,32 +19838,32 @@ async function commitDeveloperMessageForce(content, clientId) {
     return await commitDeveloperMessageForceInternal(content, clientId);
 }
 
-const METHOD_NAME$M = "function.commit.commitSystemMessage";
+const METHOD_NAME$N = "function.commit.commitSystemMessage";
 /**
  * Function implementation
 */
 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$M, {
+        swarm$1.loggerService.log(METHOD_NAME$N, {
             content,
             clientId,
             mode,
         });
     // Validate the session and swarm to ensure they exist and are accessible
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$M);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$N);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$M);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$N);
     if (payload) {
         return await PayloadContextService.runInContext(async () => {
-            await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$M, clientId, swarmName);
+            await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$N, clientId, swarmName);
         }, {
             clientId,
             payload,
         });
     }
     // Commit the user message to the agent's history via the session public service without checking the active agent
-    return await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$M, clientId, swarmName);
+    return await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$N, 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.
@@ -19894,27 +19886,27 @@ async function commitUserMessageForce(content, mode, clientId, payload) {
 }
 
 /** @private Constant defining the method name for logging and validation context*/
-const METHOD_NAME$L = "function.commit.commitAssistantMessage";
+const METHOD_NAME$M = "function.commit.commitAssistantMessage";
 /**
  * Function implementation
 */
 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$L, {
+        swarm$1.loggerService.log(METHOD_NAME$M, {
             content,
             clientId,
             agentName,
         });
     // Validate the agent exists
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$L);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$M);
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$L);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$M);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$L);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$M);
     // Check if the current agent matches the provided agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$L, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$M, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "commitAssistantMessage" skipped due to the agent change', {
@@ -19925,7 +19917,7 @@ const commitAssistantMessageInternal = beginContext(async (content, clientId, ag
         return;
     }
     // Commit the assistant message via SessionPublicService
-    await swarm$1.sessionPublicService.commitAssistantMessage(content, METHOD_NAME$L, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitAssistantMessage(content, METHOD_NAME$M, clientId, swarmName);
 });
 /**
  * Commits an assistant-generated message to the active agent in the swarm system.
@@ -19946,24 +19938,24 @@ async function commitAssistantMessage(content, clientId, agentName) {
 }
 
 /** @private Constant defining the method name for logging and validation context*/
-const METHOD_NAME$K = "function.commit.commitAssistantMessageForce";
+const METHOD_NAME$L = "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$K, {
+        swarm$1.loggerService.log(METHOD_NAME$L, {
             content,
             clientId,
         });
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$K);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$L);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$K);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$L);
     // Commit the assistant message via SessionPublicService without agent checks
-    await swarm$1.sessionPublicService.commitAssistantMessage(content, METHOD_NAME$K, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitAssistantMessage(content, METHOD_NAME$L, clientId, swarmName);
 });
 /**
  * Forcefully commits an assistant-generated message to a session in the swarm system, without checking the active agent.
@@ -19984,26 +19976,26 @@ async function commitAssistantMessageForce(content, clientId) {
 }
 
 /** @private Constant defining the method name for logging and validation context*/
-const METHOD_NAME$J = "function.commit.cancelOutput";
+const METHOD_NAME$K = "function.commit.cancelOutput";
 /**
  * Function implementation
 */
 const cancelOutputInternal = beginContext(async (clientId, agentName) => {
     // Log the cancellation attempt if enabled
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$J, {
+        swarm$1.loggerService.log(METHOD_NAME$K, {
             clientId,
             agentName,
         });
     // Validate the agent exists
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$J);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$K);
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$J);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$K);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$J);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$K);
     // Check if the current agent matches the provided agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$J, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$K, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "cancelOutput" skipped due to the agent change', {
@@ -20014,7 +20006,7 @@ const cancelOutputInternal = beginContext(async (clientId, agentName) => {
         return;
     }
     // Perform the output cancellation via SwarmPublicService
-    await swarm$1.swarmPublicService.cancelOutput(METHOD_NAME$J, clientId, swarmName);
+    await swarm$1.swarmPublicService.cancelOutput(METHOD_NAME$K, clientId, swarmName);
 });
 /**
  * Cancels the awaited output for a specific client and agent by emitting an empty string.
@@ -20033,23 +20025,23 @@ async function cancelOutput(clientId, agentName) {
 }
 
 /** @private Constant defining the method name for logging and validation context*/
-const METHOD_NAME$I = "function.commit.cancelOutputForce";
+const METHOD_NAME$J = "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$I, {
+        swarm$1.loggerService.log(METHOD_NAME$J, {
             clientId,
         });
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$I);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$J);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$I);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$J);
     // Perform the output cancellation via SwarmPublicService without agent checks
-    await swarm$1.swarmPublicService.cancelOutput(METHOD_NAME$I, clientId, swarmName);
+    await swarm$1.swarmPublicService.cancelOutput(METHOD_NAME$J, clientId, swarmName);
 });
 /**
  * Forcefully cancels the awaited output for a specific client by emitting an empty string, without checking the active agent.
@@ -20067,22 +20059,22 @@ async function cancelOutputForce(clientId) {
     return await cancelOutputForceInternal(clientId);
 }
 
-const METHOD_NAME$H = "function.commit.commitToolRequest";
+const METHOD_NAME$I = "function.commit.commitToolRequest";
 /**
  * Function implementation
 */
 const commitToolRequestInternal = beginContext(async (request, clientId, agentName) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$H, {
+        swarm$1.loggerService.log(METHOD_NAME$I, {
             request,
             clientId,
             agentName,
         });
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$H);
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$H);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$I);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$I);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$H);
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$H, clientId, swarmName);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$I);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$I, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "commitToolRequest" skipped due to the agent change', {
@@ -20092,7 +20084,7 @@ const commitToolRequestInternal = beginContext(async (request, clientId, agentNa
             });
         return null;
     }
-    return await swarm$1.sessionPublicService.commitToolRequest(Array.isArray(request) ? request : [request], METHOD_NAME$H, clientId, swarmName);
+    return await swarm$1.sessionPublicService.commitToolRequest(Array.isArray(request) ? request : [request], METHOD_NAME$I, clientId, swarmName);
 });
 /**
  * Commits a tool request to the active agent in the swarm system.
@@ -20107,21 +20099,21 @@ async function commitToolRequest(request, clientId, agentName) {
     return await commitToolRequestInternal(request, clientId, agentName);
 }
 
-const METHOD_NAME$G = "function.commit.commitToolRequestForce";
+const METHOD_NAME$H = "function.commit.commitToolRequestForce";
 /**
  * Function implementation
 */
 const commitToolRequestForceInternal = beginContext(async (request, clientId) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$G, {
+        swarm$1.loggerService.log(METHOD_NAME$H, {
             request,
             clientId,
         });
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$G);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$H);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$G);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$H);
     const requests = Array.isArray(request) ? request : [request];
-    return await swarm$1.sessionPublicService.commitToolRequest(requests, METHOD_NAME$G, clientId, swarmName);
+    return await swarm$1.sessionPublicService.commitToolRequest(requests, METHOD_NAME$H, clientId, swarmName);
 });
 /**
  * Forcefully commits a tool request to the active agent in the swarm system.
@@ -20138,17 +20130,17 @@ async function commitToolRequestForce(request, clientId) {
 }
 
 /** @constant {string} METHOD_NAME - The name of the method used for logging and validation*/
-const METHOD_NAME$F = "function.target.ask";
+const METHOD_NAME$G = "function.target.ask";
 /**
  * Function implementation
 */
 const askInternal = beginContext(async (message, advisorName) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$F, {
+        swarm$1.loggerService.log(METHOD_NAME$G, {
             message,
             advisorName,
         });
-    swarm$1.advisorValidationService.validate(advisorName, METHOD_NAME$F);
+    swarm$1.advisorValidationService.validate(advisorName, METHOD_NAME$G);
     const { getChat, callbacks } = swarm$1.advisorSchemaService.get(advisorName);
     if (callbacks?.onChat) {
         callbacks.onChat(message);
@@ -20187,7 +20179,7 @@ async function ask(message, advisorName) {
     return await askInternal(message, advisorName);
 }
 
-const METHOD_NAME$E = "function.target.json";
+const METHOD_NAME$F = "function.target.json";
 const MAX_ATTEMPTS = 5;
 /**
  * A class implementing the IOutlineHistory interface to manage a history of outline messages.
@@ -20231,13 +20223,14 @@ class OutlineHistory {
 */
 const jsonInternal = beginContext(async (outlineName, param) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$E, {});
-    swarm$1.outlineValidationService.validate(outlineName, METHOD_NAME$E);
+        swarm$1.loggerService.log(METHOD_NAME$F, {});
+    swarm$1.outlineValidationService.validate(outlineName, METHOD_NAME$F);
     const resultId = functoolsKit.randomString();
     const clientId = `${resultId}_outline`;
     const { getOutlineHistory, completion, validations = [], maxAttempts = MAX_ATTEMPTS, format, prompt, system, callbacks: outlineCallbacks, } = swarm$1.outlineSchemaService.get(outlineName);
-    swarm$1.completionValidationService.validate(completion, METHOD_NAME$E);
-    const { getCompletion, flags = [], callbacks: completionCallbacks, } = swarm$1.completionSchemaService.get(completion);
+    swarm$1.completionValidationService.validate(completion, METHOD_NAME$F);
+    const completionSchema = swarm$1.completionSchemaService.get(completion);
+    const { getCompletion, flags = [], callbacks: completionCallbacks, } = completionSchema;
     let errorMessage = "";
     let history;
     const modelPrompt = typeof prompt === "function" ? await prompt(outlineName) : prompt;
@@ -20299,8 +20292,9 @@ const jsonInternal = beginContext(async (outlineName, param) => {
             if (completionCallbacks?.onComplete) {
                 completionCallbacks.onComplete({
                     messages,
-                    mode: "tool",
                     outlineName,
+                    format,
+                    clientId,
                 }, output);
             }
             const data = JSON.parse(output.content);
@@ -20369,6 +20363,61 @@ async function json(outlineName, param = {}) {
     return await jsonInternal(outlineName, param);
 }
 
+const METHOD_NAME$E = "function.target.chat";
+/**
+ * Internal function to process a chat completion request.
+ * Executes outside existing contexts using `beginContext` to ensure isolation.
+ * Processes a single completion request and returns the output message.
+ * @private
+ * @async
+ */
+const chatInternal = beginContext(async (completionName, messages) => {
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
+        swarm$1.loggerService.log(METHOD_NAME$E, {});
+    swarm$1.completionValidationService.validate(completionName, METHOD_NAME$E);
+    const resultId = functoolsKit.randomString();
+    const clientId = `${resultId}_chat`;
+    const completionSchema = swarm$1.completionSchemaService.get(completionName);
+    if (completionSchema.json) {
+        throw new Error(`${METHOD_NAME$E} completion ${completionName} should not have json=true. Use a non-JSON completion for chat.`);
+    }
+    const { getCompletion } = completionSchema;
+    let errorValue = null;
+    const unError = errorSubject.subscribe(([errorClientId, error]) => {
+        if (clientId === errorClientId) {
+            errorValue = error;
+        }
+    });
+    const { content } = await getCompletion({
+        clientId,
+        messages,
+        mode: "user",
+    });
+    unError();
+    if (errorValue) {
+        throw errorValue;
+    }
+    return content;
+});
+/**
+ * Processes a chat completion request by sending messages to a specified completion service.
+ * Delegates to an internal context-isolated function to ensure clean execution.
+ * @async
+ *
+ * @param completionName The name of the completion service to use.
+ * @param messages Array of messages representing the conversation history.
+ * @example
+ * // Example usage
+ * const output = await chat("openai", [
+ *   { role: "system", content: "You are a helpful assistant." },
+ *   { role: "user", content: "Hello, how are you?" }
+ * ]);
+ * console.log(output.content); // Logs the completion output
+ */
+async function chat(completionName, messages) {
+    return await chatInternal(completionName, messages);
+}
+
 const METHOD_NAME$D = "function.target.disposeConnection";
 /**
  * Disposes of a client session and all related resources within a swarm.
@@ -21551,7 +21600,7 @@ const getAgentHistoryInternal = beginContext(async (clientId, agentName) => {
  * @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
+ * console.log(history); // Outputs array of ISwarmMessage objects
  */
 async function getAgentHistory(clientId, agentName) {
     return await getAgentHistoryInternal(clientId, agentName);
@@ -24556,6 +24605,7 @@ exports.cancelOutputForce = cancelOutputForce;
 exports.changeToAgent = changeToAgent;
 exports.changeToDefaultAgent = changeToDefaultAgent;
 exports.changeToPrevAgent = changeToPrevAgent;
+exports.chat = chat;
 exports.commitAssistantMessage = commitAssistantMessage;
 exports.commitAssistantMessageForce = commitAssistantMessageForce;
 exports.commitDeveloperMessage = commitDeveloperMessage;