agent-swarm-kit 3.1.0 → 4.0.0

package/build/index.mjs

@@ -273,33 +273,32 @@ const validateDefault = async (output) => {
 };
 
 /**
- * Removes XML tags and their contents from a string, cleaning up excess whitespace.
- * Strips all matched XML-like tags (e.g., `<tag>content</tag>`) and normalizes newlines, returning a trimmed result.
- *
- *                  Returns an empty string if the input is falsy.
+ * Removes XML-like blocks — the tags TOGETHER with everything between them — from a string, cleaning up excess whitespace.
+ * Any `<tag>content</tag>` pair is stripped entirely (tag and content), so only text outside such blocks survives.
+ * Returns an empty string if the input is falsy.
  *
  * @example
- * // Basic usage with XML tags
- * console.log(removeXmlTags("<p>Hello</p>")); // "Hello"
- * console.log(removeXmlTags("<div><span>Text</span></div>")); // "Text"
+ * // Whole blocks are removed, including their contents
+ * console.log(removeXmlTags("<p>Hello</p>")); // ""
+ * console.log(removeXmlTags("Text <tool>action</tool>")); // "Text"
  * console.log(removeXmlTags("No tags here")); // "No tags here"
  *
  * @example
- * // Handling multiline input and edge cases
- * console.log(removeXmlTags("<tag>\nLine1\nLine2\n</tag>")); // "Line1\nLine2"
- * console.log(removeXmlTags("<tag>  <nested>Text</nested>  </tag>")); // "Text"
+ * // Edge cases
+ * console.log(removeXmlTags("<think>\nreasoning\n</think>Answer")); // "Answer"
+ * console.log(removeXmlTags("<invalid>")); // "<invalid>" (unpaired tags are kept)
  * console.log(removeXmlTags("")); // ""
  * console.log(removeXmlTags(null)); // ""
  *
  * @remarks
  * This function:
  * - Returns an empty string (`""`) for falsy inputs (e.g., `null`, `undefined`, empty string) to ensure safe handling.
- * - Uses a regular expression (`/<[^>]+>[\s\S]*?<\/[^>]+>/g`) to match and remove XML tags and their contents, including nested tags,
- *   where `[\s\S]*?` ensures non-greedy matching across newlines.
+ * - Uses a regular expression (`/<[^>]+>[\s\S]*?<\/[^>]+>/g`) to match an opening tag, its (non-greedy) contents across
+ *   newlines, and a closing tag, removing the whole block; unpaired tags without a closing counterpart are left as-is.
  * - Collapses multiple consecutive newlines (`\n\s*\n`) into a single newline (`\n`) to clean up formatting.
  * - Trims leading and trailing whitespace from the final result for a polished output.
- * Useful in the agent swarm system for sanitizing model outputs, user inputs, or logs that may contain XML markup,
- * such as when processing tool call responses or cleaning structured text.
+ * Useful in the agent swarm system for stripping structured blocks from model outputs — e.g., `<think>…</think>`
+ * reasoning sections or inline `<tool_call>…</tool_call>` artifacts — leaving only the plain-text answer.
  *
  * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_expressions|Regular Expressions}
  * for details on the regex patterns used.
@@ -317,6 +316,12 @@ const removeXmlTags = (input) => {
 };
 
 const IS_WINDOWS = os.platform() === "win32";
+/**
+ * Default prefix for temporary files created during atomic writes.
+ * Exposed so directory scanners (e.g. PersistBase) can exclude in-flight
+ * or leftover temporary files from entity listings.
+*/
+const TMP_FILE_PREFIX = ".tmp-";
 /**
  * Atomically writes data to a file, ensuring the operation either fully completes or leaves the original file unchanged.
  * Uses a temporary file with a rename strategy on POSIX systems for atomicity, or direct writing with sync on Windows (or when POSIX rename is skipped).
@@ -367,7 +372,7 @@ async function writeFileAtomic(file, data, options = {}) {
     else if (!options) {
         options = {};
     }
-    const { encoding = "utf8", mode = 0o666, tmpPrefix = ".tmp-" } = options;
+    const { encoding = "utf8", mode = 0o666, tmpPrefix = TMP_FILE_PREFIX } = options;
     let fileHandle = null;
     if (IS_WINDOWS || GLOBAL_CONFIG.CC_SKIP_POSIX_RENAME) {
         try {
@@ -423,6 +428,13 @@ async function writeFileAtomic(file, data, options = {}) {
 }
 
 var _a$4, _b$1, _c, _d;
+/**
+ * Checks whether a directory entry name represents a persisted entity file.
+ * Excludes temporary files produced by atomic writes so in-flight or leftover
+ * `.tmp-*` files are never listed, counted, read, or removed as entities.
+ * @private
+ */
+const isEntityFileName = (name) => name.endsWith(".json") && !name.startsWith(TMP_FILE_PREFIX);
 /** @private Symbol for memoizing the wait-for-initialization operation in PersistBase*/
 const BASE_WAIT_FOR_INIT_SYMBOL = Symbol("wait-for-init");
 /** @private Symbol for creating a new key in a persistent list*/
@@ -525,6 +537,8 @@ const LIST_GET_LAST_KEY_FN_METHOD_NAME = "PersistList.getLastKeyFn";
 const BASE_UNLINK_RETRY_COUNT = 5;
 /** @private Delay for retry attempts for unlink in waitForInit (in milliseconds)*/
 const BASE_UNLINK_RETRY_DELAY = 1000;
+/** @private Minimum age for a temporary atomic-write file to be reaped as a leftover in waitForInit (in milliseconds)*/
+const BASE_STALE_TMP_FILE_AGE = 120000;
 /**
  * Attempts to remove a file if invalid JSON is detected during initialization.
  * Retries the operation multiple times with delays to handle transient errors, ensuring robust setup.
@@ -555,6 +569,21 @@ const BASE_WAIT_FOR_INIT_FN = async (self) => {
             directory: self._directory,
         });
     await fs__default.mkdir(self._directory, { recursive: true });
+    for await (const entry of await fs__default.opendir(self._directory)) {
+        if (entry.isFile() && entry.name.startsWith(TMP_FILE_PREFIX)) {
+            const filePath = join(self._directory, entry.name);
+            // An in-flight atomic write from a concurrent process also produces a
+            // temporary file here; only reap ones old enough to be true leftovers.
+            const stat = await fs__default.stat(filePath).catch(() => null);
+            if (!stat || Date.now() - stat.mtimeMs < BASE_STALE_TMP_FILE_AGE) {
+                continue;
+            }
+            console.error(`agent-swarm PersistBase found leftover temporary file for filePath=${filePath} entityName=${self.entityName}`);
+            if (await not(BASE_WAIT_FOR_INIT_UNLINK_FN(filePath))) {
+                console.error(`agent-swarm PersistBase failed to remove leftover temporary file for filePath=${filePath} entityName=${self.entityName}`);
+            }
+        }
+    }
     for await (const key of self.keys()) {
         try {
             await self.readValue(key);
@@ -678,7 +707,11 @@ class PersistBase {
      * @private
      */
     _getFilePath(entityId) {
-        return join(this.baseDir, this.entityName, `${entityId}.json`);
+        // entityId comes from clientId/stateName/etc. which may be attacker-supplied:
+        // strip path separators and traversal so a value like "../../x" cannot escape
+        // the entity directory and read/overwrite arbitrary files.
+        const safeId = String(entityId).replace(/[/\\]/g, "_").replace(/\.\./g, "_");
+        return join(this.baseDir, this.entityName, `${safeId}.json`);
     }
     /**
      * Initializes the storage directory, creating it if it doesn’t exist, and validates existing entities.
@@ -701,7 +734,7 @@ class PersistBase {
     async getCount() {
         let count = 0;
         for await (const entry of await fs__default.opendir(this._directory)) {
-            if (entry.isFile() && entry.name.endsWith(".json")) {
+            if (entry.isFile() && isEntityFileName(entry.name)) {
                 count++;
             }
         }
@@ -810,7 +843,7 @@ class PersistBase {
         try {
             const filesToRemove = [];
             for await (const entry of await fs__default.opendir(this._directory)) {
-                if (entry.isFile() && entry.name.endsWith(".json")) {
+                if (entry.isFile() && isEntityFileName(entry.name)) {
                     filesToRemove.push(entry.name);
                 }
             }
@@ -836,7 +869,7 @@ class PersistBase {
         try {
             const entityIds = [];
             for await (const entry of await fs__default.opendir(this._directory)) {
-                if (entry.isFile() && entry.name.endsWith(".json")) {
+                if (entry.isFile() && isEntityFileName(entry.name)) {
                     entityIds.push(entry.name.slice(0, -5));
                 }
             }
@@ -866,7 +899,7 @@ class PersistBase {
         try {
             const entityIds = [];
             for await (const entry of await fs__default.opendir(this._directory)) {
-                if (entry.isFile() && entry.name.endsWith(".json")) {
+                if (entry.isFile() && isEntityFileName(entry.name)) {
                     entityIds.push(entry.name.slice(0, -5));
                 }
             }
@@ -1791,6 +1824,16 @@ class HistoryPersistInstance {
                 this.callbacks.onRead(item, this.clientId, agentName);
                 yield item;
             }
+            if (this.callbacks.getSystemPrompt) {
+                for (const content of await this.callbacks.getSystemPrompt(this.clientId, agentName)) {
+                    yield {
+                        role: "system",
+                        content,
+                        agentName,
+                        mode: "tool",
+                    };
+                }
+            }
             this.callbacks.onReadEnd &&
                 this.callbacks.onReadEnd(this.clientId, agentName);
             return;
@@ -1972,6 +2015,16 @@ class HistoryMemoryInstance {
                 this.callbacks.onRead(item, this.clientId, agentName);
                 yield item;
             }
+            if (this.callbacks.getSystemPrompt) {
+                for (const content of await this.callbacks.getSystemPrompt(this.clientId, agentName)) {
+                    yield {
+                        role: "system",
+                        content,
+                        agentName,
+                        mode: "tool",
+                    };
+                }
+            }
             this.callbacks.onReadEnd &&
                 this.callbacks.onReadEnd(this.clientId, agentName);
             return;
@@ -2731,7 +2784,7 @@ class OperatorUtils {
         isInitial && operator.init();
         return (message, next) => {
             operator.connectAnswer(next);
-            operator.recieveMessage(message);
+            Promise.resolve(operator.recieveMessage(message)).catch((error) => console.error(`agent-swarm operator recieveMessage error clientId=${clientId} agentName=${agentName} error=${getErrorMessage(error)}`));
             return async () => {
                 this.getOperator.clear(`${clientId}-${agentName}`);
                 await operator.dispose();
@@ -2836,6 +2889,9 @@ const CC_DEFAULT_CONNECT_OPERATOR = (clientId, agentName) => OperatorAdapter.con
  * Flag to enable operator timeout, used in `ClientOperator` for message processing.
 */
 const CC_ENABLE_OPERATOR_TIMEOUT = false;
+const CC_OPERATOR_SIGNAL_TIMEOUT = 90000;
+const CC_CHAT_INACTIVITY_CHECK = 60 * 1000;
+const CC_CHAT_INACTIVITY_TIMEOUT = 15 * 60 * 1000;
 /**
  * Disable fetch of data from all storages. Quite usefull for unit tests
 */
@@ -2895,6 +2951,9 @@ const GLOBAL_CONFIG = {
     CC_THROW_WHEN_NAVIGATION_RECURSION,
     CC_DEFAULT_CONNECT_OPERATOR,
     CC_ENABLE_OPERATOR_TIMEOUT,
+    CC_OPERATOR_SIGNAL_TIMEOUT,
+    CC_CHAT_INACTIVITY_CHECK,
+    CC_CHAT_INACTIVITY_TIMEOUT,
     CC_STORAGE_DISABLE_GET_DATA,
     CC_MAX_NESTED_EXECUTIONS,
 };
@@ -3323,6 +3382,9 @@ const resolveTools = async (clientId, agentName, tools) => {
     })));
 };
 
+const disposeSubject = new Subject();
+const errorSubject = new Subject();
+
 const CANCEL_OUTPUT_SYMBOL = Symbol("cancel-output");
 const AGENT_CHANGE_SYMBOL = Symbol("agent-change");
 const MODEL_RESQUE_SYMBOL = Symbol("model-resque");
@@ -3391,7 +3453,8 @@ const createPlaceholder = () => GLOBAL_CONFIG.CC_EMPTY_OUTPUT_PLACEHOLDERS[Math.
  * Emits events via subjects (e.g., _toolErrorSubject) to manage execution flow in ClientAgent.
  * Supports AgentConnectionService by executing tools defined in ToolSchemaService and referenced in AgentSchemaService.
 */
-const createToolCall = async (idx, tool, toolCalls, targetFn, reason, self) => {
+const createToolCall = async (idx, tool, toolCalls, targetFn, reason, mode, outputEpoch, self) => {
+    self._runningToolCalls += 1;
     try {
         await targetFn.call({
             toolId: tool.id,
@@ -3404,8 +3467,15 @@ const createToolCall = async (idx, tool, toolCalls, targetFn, reason, self) => {
             callReason: reason,
             toolCalls,
         });
-        targetFn.callbacks?.onAfterCall &&
-            targetFn.callbacks?.onAfterCall(tool.id, self.params.clientId, self.params.agentName, tool.function.arguments);
+        try {
+            targetFn.callbacks?.onAfterCall &&
+                targetFn.callbacks?.onAfterCall(tool.id, self.params.clientId, self.params.agentName, tool.function.arguments);
+        }
+        catch (error) {
+            // Callbacks are observers: a throwing onAfterCall must not turn a
+            // successful tool call into a tool error.
+            console.error(`agent-swarm onAfterCall callback error functionName=${tool.function.name} error=${getErrorMessage(error)}`);
+        }
     }
     catch (error) {
         console.error(`agent-swarm tool call error functionName=${tool.function.name} error=${getErrorMessage(error)}`, {
@@ -3415,11 +3485,29 @@ const createToolCall = async (idx, tool, toolCalls, targetFn, reason, self) => {
             arguments: tool.function.arguments,
             error: errorData(error),
         });
-        targetFn.callbacks?.onCallError &&
-            targetFn.callbacks?.onCallError(tool.id, self.params.clientId, self.params.agentName, tool.function.arguments, error);
-        self.params.callbacks?.onToolError &&
-            self.params.callbacks.onToolError(self.params.clientId, self.params.agentName, targetFn.toolName, error);
-        self._toolErrorSubject.next(TOOL_ERROR_SYMBOL);
+        try {
+            targetFn.callbacks?.onCallError &&
+                targetFn.callbacks?.onCallError(tool.id, self.params.clientId, self.params.agentName, tool.function.arguments, error);
+            self.params.onToolError &&
+                self.params.onToolError(self.params.clientId, self.params.agentName, targetFn.toolName, error);
+        }
+        catch (callbackError) {
+            // Error callbacks must not be able to suppress the TOOL_ERROR signal
+            // below — otherwise the execution would never recover and hang.
+            console.error(`agent-swarm onCallError callback error functionName=${tool.function.name} error=${getErrorMessage(callbackError)}`);
+        }
+        await self._toolErrorSubject.next(TOOL_ERROR_SYMBOL);
+        if (!self._activeToolChains) {
+            // The status chain already consumed TOOL_COMMIT and finished, so nobody
+            // handles this late error (e.g. changeToAgent recursion guard thrown after
+            // commitToolOutput). Without a recovery emission the pending waitForOutput
+            // of the enclosing execution would hang forever.
+            const result = await self._resurrectModel(mode, `Late tool error after commit: name=${tool.function.name} error=${getErrorMessage(error)}`);
+            await self._emitOutput(mode, result, outputEpoch);
+        }
+    }
+    finally {
+        self._runningToolCalls -= 1;
     }
 };
 /**
@@ -3449,7 +3537,7 @@ const mapMcpToolCall = ({ name, description = name, inputSchema }, self) => {
                         enum: e,
                     },
                 }), {}),
-                required: inputSchema.required,
+                required: inputSchema?.required,
             },
         },
         call: async (dto) => {
@@ -3538,6 +3626,7 @@ const EXECUTE_FN = async (incoming, mode, self) => {
         self.params.logger.debug(`ClientAgent agentName=${self.params.agentName} clientId=${self.params.clientId} maxToolCalls=${self.params.maxToolCalls} execute begin`, { incoming, mode });
     self.params.onExecute &&
         self.params.onExecute(self.params.clientId, self.params.agentName, incoming, mode);
+    const outputEpoch = self._outputEpoch;
     await self.params.history.push({
         role: "user",
         mode,
@@ -3555,7 +3644,39 @@ const EXECUTE_FN = async (incoming, mode, self) => {
             id: call.id ?? randomString(),
             type: call.type ?? "function",
         })), self.params.clientId, self.params.agentName);
-        toolCalls = toolCalls.slice(-self.params.maxToolCalls);
+        {
+            const toolCallIds = new Set(toolCalls.map(({ id }) => id));
+            if (toolCallIds.size !== toolCalls.length) {
+                // Duplicate ids break the call-to-output linkage in history and mean
+                // the model output is malformed: surface it as an exception to the
+                // caller (via errorSubject) and recover the flow with a placeholder.
+                const error = new Error(`agent-swarm duplicate tool call id detected agentName=${self.params.agentName} clientId=${self.params.clientId} ids=${JSON.stringify(toolCalls.map(({ id }) => id))}`);
+                console.error(error.message);
+                await errorSubject.next([self.params.clientId, error]);
+                const result = await self._resurrectModel(mode, `Duplicate tool call id in model output`);
+                await self._emitOutput(mode, result, outputEpoch);
+                return;
+            }
+        }
+        // slice(-0) === slice(0) returns the WHOLE array, so maxToolCalls=0 would
+        // run every call instead of none — clamp explicitly.
+        toolCalls =
+            self.params.maxToolCalls > 0
+                ? toolCalls.slice(-self.params.maxToolCalls)
+                : [];
+        if (!toolCalls.length) {
+            // maxToolCalls=0 dropped every call: the model wanted tools but none may
+            // run. Emit the (tool-stripped) content as the answer instead of leaving
+            // the pending waitForOutput hanging forever.
+            const result = await self.params.transform(message.content, self.params.clientId, self.params.agentName);
+            await self.params.history.push({
+                ...message,
+                tool_calls: [],
+                agentName: self.params.agentName,
+            });
+            await self._emitOutput(mode, result, outputEpoch);
+            return;
+        }
         {
             const priorityTool = toolCalls.find((call) => swarm$1.navigationSchemaService.hasTool(call.function.name) ||
                 swarm$1.actionSchemaService.hasTool(call.function.name));
@@ -3563,11 +3684,15 @@ const EXECUTE_FN = async (incoming, mode, self) => {
                 toolCalls = [priorityTool];
             }
         }
+        // Persist the normalized tool calls (ids ensured, sliced, priority-filtered)
+        // so history keeps the call-to-output linkage even when the model omits ids.
         await self.params.history.push({
             ...message,
+            tool_calls: toolCalls,
             agentName: self.params.agentName,
         });
         let lastToolStatusRef = Promise.resolve(null);
+        self._activeToolChains += 1;
         const [runAwaiter, { resolve: run }] = createAwaiter();
         for (let idx = 0; idx !== toolCalls.length; idx++) {
             const tool = toolCalls[idx];
@@ -3578,29 +3703,52 @@ const EXECUTE_FN = async (incoming, mode, self) => {
                 const result = await self._resurrectModel(mode, `No target function for ${tool.function.name}`);
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
                     self.params.logger.debug(`ClientAgent agentName=${self.params.agentName} clientId=${self.params.clientId} execute end result=${result}`);
-                await self._emitOutput(mode, result);
+                await self._emitOutput(mode, result, outputEpoch);
                 run(false);
                 return;
             }
-            targetFn.callbacks?.onValidate &&
-                targetFn.callbacks?.onValidate(self.params.clientId, self.params.agentName, tool.function.arguments);
-            if (await not(targetFn.validate({
-                clientId: self.params.clientId,
-                agentName: self.params.agentName,
-                params: tool.function.arguments,
-                toolCalls,
-            }))) {
+            try {
+                targetFn.callbacks?.onValidate &&
+                    targetFn.callbacks?.onValidate(self.params.clientId, self.params.agentName, tool.function.arguments);
+            }
+            catch (error) {
+                // Callbacks are observers: a throwing onValidate must not reject the
+                // queued EXECUTE_FN (unhandled rejection + hung waitForOutput).
+                console.error(`agent-swarm onValidate callback error functionName=${tool.function.name} error=${getErrorMessage(error)}`);
+            }
+            let validationPassed = false;
+            try {
+                validationPassed = !(await not(targetFn.validate({
+                    clientId: self.params.clientId,
+                    agentName: self.params.agentName,
+                    params: tool.function.arguments,
+                    toolCalls,
+                })));
+            }
+            catch (error) {
+                // A throwing validate is a failed validation, not a crashed execution.
+                console.error(`agent-swarm tool validate error functionName=${tool.function.name} error=${getErrorMessage(error)}`);
+                validationPassed = false;
+            }
+            if (!validationPassed) {
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
                     self.params.logger.debug(`ClientAgent agentName=${self.params.agentName} clientId=${self.params.clientId} functionName=${tool.function.name} tool validation not passed`);
                 const result = await self._resurrectModel(mode, `Function validation failed: name=${tool.function.name} arguments=${JSON.stringify(tool.function.arguments)}`);
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
                     self.params.logger.debug(`ClientAgent agentName=${self.params.agentName} clientId=${self.params.clientId} execute end result=${result}`);
-                await self._emitOutput(mode, result);
+                await self._emitOutput(mode, result, outputEpoch);
                 run(false);
                 return;
             }
-            targetFn.callbacks?.onBeforeCall &&
-                targetFn.callbacks?.onBeforeCall(tool.id, self.params.clientId, self.params.agentName, tool.function.arguments);
+            try {
+                targetFn.callbacks?.onBeforeCall &&
+                    targetFn.callbacks?.onBeforeCall(tool.id, self.params.clientId, self.params.agentName, tool.function.arguments);
+            }
+            catch (error) {
+                // Callbacks are observers: a throwing onBeforeCall must not reject the
+                // queued EXECUTE_FN (unhandled rejection + hung waitForOutput).
+                console.error(`agent-swarm onBeforeCall callback error functionName=${tool.function.name} error=${getErrorMessage(error)}`);
+            }
             /**
              * Do not await directly to avoid deadlock! The tool can send messages to other agents by emulating user messages.
              */
@@ -3638,33 +3786,33 @@ const EXECUTE_FN = async (incoming, mode, self) => {
                         console.warn(`agent-swarm no tool output after ${TOOL_NO_OUTPUT_WARNING_TIMEOUT}ms clientId=${self.params.clientId} agentName=${self.params.agentName} toolId=${tool.id} functionName=${tool.function.name}`);
                     }
                 });
-                createToolCall(idx, tool, toolCalls, targetFn, message.content || "", self);
+                createToolCall(idx, tool, toolCalls, targetFn, message.content || "", mode, outputEpoch, self);
                 const status = await statusAwaiter;
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
                     self.params.logger.debug(`ClientAgent agentName=${self.params.agentName} clientId=${self.params.clientId} functionName=${tool.function.name} tool call end`);
                 if (status === MODEL_RESQUE_SYMBOL) {
                     GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
                         self.params.logger.debug(`ClientAgent agentName=${self.params.agentName} clientId=${self.params.clientId} functionName=${tool.function.name} the next tool execution stopped due to the model resque`);
-                    self.params.callbacks?.onAfterToolCalls &&
-                        self.params.callbacks.onAfterToolCalls(self.params.clientId, self.params.agentName, toolCalls);
+                    self.params.onAfterToolCalls &&
+                        self.params.onAfterToolCalls(self.params.clientId, self.params.agentName, toolCalls);
                 }
                 if (status === AGENT_CHANGE_SYMBOL) {
                     GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
                         self.params.logger.debug(`ClientAgent agentName=${self.params.agentName} clientId=${self.params.clientId} functionName=${tool.function.name} the next tool execution stopped due to the agent changed`);
-                    self.params.callbacks?.onAfterToolCalls &&
-                        self.params.callbacks.onAfterToolCalls(self.params.clientId, self.params.agentName, toolCalls);
+                    self.params.onAfterToolCalls &&
+                        self.params.onAfterToolCalls(self.params.clientId, self.params.agentName, toolCalls);
                 }
                 if (status === TOOL_STOP_SYMBOL) {
                     GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
                         self.params.logger.debug(`ClientAgent agentName=${self.params.agentName} clientId=${self.params.clientId} functionName=${tool.function.name} the next tool execution stopped due to the commitStopTools call`);
-                    self.params.callbacks?.onAfterToolCalls &&
-                        self.params.callbacks.onAfterToolCalls(self.params.clientId, self.params.agentName, toolCalls);
+                    self.params.onAfterToolCalls &&
+                        self.params.onAfterToolCalls(self.params.clientId, self.params.agentName, toolCalls);
                 }
                 if (status === CANCEL_OUTPUT_SYMBOL) {
                     GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
                         self.params.logger.debug(`ClientAgent agentName=${self.params.agentName} clientId=${self.params.clientId} functionName=${tool.function.name} the next tool execution stopped due to the commitCancelOutput call`);
-                    self.params.callbacks?.onAfterToolCalls &&
-                        self.params.callbacks.onAfterToolCalls(self.params.clientId, self.params.agentName, toolCalls);
+                    self.params.onAfterToolCalls &&
+                        self.params.onAfterToolCalls(self.params.clientId, self.params.agentName, toolCalls);
                 }
                 if (status === TOOL_ERROR_SYMBOL) {
                     GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
@@ -3672,14 +3820,15 @@ const EXECUTE_FN = async (incoming, mode, self) => {
                     const result = await self._resurrectModel(mode, `Function call failed with error: name=${tool.function.name} arguments=${JSON.stringify(tool.function.arguments)}`);
                     GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
                         self.params.logger.debug(`ClientAgent agentName=${self.params.agentName} clientId=${self.params.clientId} execute end result=${result}`);
-                    await self._emitOutput(mode, result);
+                    await self._emitOutput(mode, result, outputEpoch);
                 }
                 return status;
             });
         }
         lastToolStatusRef.finally(() => {
-            self.params.callbacks?.onAfterToolCalls &&
-                self.params.callbacks.onAfterToolCalls(self.params.clientId, self.params.agentName, toolCalls);
+            self._activeToolChains -= 1;
+            self.params.onAfterToolCalls &&
+                self.params.onAfterToolCalls(self.params.clientId, self.params.agentName, toolCalls);
         });
         run(true);
         return;
@@ -3698,12 +3847,12 @@ const EXECUTE_FN = async (incoming, mode, self) => {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
             self.params.logger.debug(`ClientAgent agentName=${self.params.agentName} clientId=${self.params.clientId} execute invalid tool call detected: ${validation}`, { result });
         const result1 = await self._resurrectModel(mode, `Invalid model output: ${result}`);
-        await self._emitOutput(mode, result1);
+        await self._emitOutput(mode, result1, outputEpoch);
         return;
     }
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
         self.params.logger.debug(`ClientAgent agentName=${self.params.agentName} clientId=${self.params.clientId} execute end result=${result}`);
-    await self._emitOutput(mode, result);
+    await self._emitOutput(mode, result, outputEpoch);
 };
 /**
  * Represents a client-side agent in the swarm system, implementing the IAgent interface.
@@ -3726,6 +3875,35 @@ class ClientAgent {
          * @readonly
          */
         this._toolAbortController = new ToolAbortController();
+        /**
+         * Count of tool calls currently executing for this agent.
+         * Non-zero while any targetFn.call promise is pending; ClientSession uses it to
+         * detect nested tool-mode executions that must join the parent output waiter.
+         */
+        this._runningToolCalls = 0;
+        /**
+         * Count of EXECUTE_FN tool status chains still consuming tool events.
+         * While non-zero, tool errors are handled by the chain (stop + resurrect);
+         * once it drops to zero a late tool error must recover on its own in
+         * createToolCall, or the pending execution output would never be emitted.
+         */
+        this._activeToolChains = 0;
+        /**
+         * Count of EXECUTE_FN executions currently in flight for this agent instance.
+         * dispose() checks it: tearing the instance down mid-execution (e.g. a
+         * server-side changeToAgent while the completion is still running) must
+         * resolve the pending output waiter with an empty result — otherwise the
+         * waiter and the session busy lock would hang forever.
+         */
+        this._activeExecutions = 0;
+        /**
+         * Generation counter for output emissions. Bumped by commitCancelOutput and by
+         * swarm-level output substitution (emit). Executions capture the epoch at start
+         * and _emitOutput drops their result when the epoch moved on — otherwise the
+         * stale output of a cancelled/substituted execution would resolve the waiter
+         * of the NEXT message, poisoning that exchange.
+         */
+        this._outputEpoch = 0;
         /**
          * Subject for signaling agent changes, halting subsequent tool executions via commitAgentChange.
          * @readonly
@@ -3765,7 +3943,15 @@ class ClientAgent {
          * Executes the incoming message and processes tool calls if present, queued to prevent overlapping executions.
          * Implements IAgent.execute, delegating to EXECUTE_FN with queuing via functools-kit’s queued decorator.
          */
-        this.execute = queued(async (incoming, mode) => await EXECUTE_FN(incoming, mode, this));
+        this.execute = queued(async (incoming, mode) => {
+            this._activeExecutions += 1;
+            try {
+                return await EXECUTE_FN(incoming, mode, this);
+            }
+            finally {
+                this._activeExecutions -= 1;
+            }
+        });
         /**
          * Runs a stateless completion for the incoming message, queued to prevent overlapping executions.
          * Implements IAgent.run, delegating to RUN_FN with queuing via functools-kit’s queued decorator.
@@ -3789,12 +3975,32 @@ class ClientAgent {
         if (this.params.tools) {
             await Promise.all(this.params.tools.map(async (tool) => {
                 const { toolName, function: upperFn, isAvailable = TOOL_AVAILABLE_DEFAULT, ...other } = tool;
-                if (await not(isAvailable(this.params.clientId, this.params.agentName, toolName))) {
+                try {
+                    if (await not(isAvailable(this.params.clientId, this.params.agentName, toolName))) {
+                        return;
+                    }
+                }
+                catch (error) {
+                    // A throwing isAvailable would reject the queued EXECUTE_FN and
+                    // hang the pending waitForOutput: treat it as "not available".
+                    console.error(`agent-swarm isAvailable error toolName=${toolName} error=${getErrorMessage(error)}`);
+                    await errorSubject.next([this.params.clientId, error]);
+                    return;
+                }
+                let fn;
+                try {
+                    fn =
+                        typeof upperFn === "function"
+                            ? await upperFn(this.params.clientId, this.params.agentName)
+                            : upperFn;
+                }
+                catch (error) {
+                    // Same rationale: a throwing dynamic tool schema must not crash
+                    // the execution — the tool is skipped for this completion.
+                    console.error(`agent-swarm dynamic tool function error toolName=${toolName} error=${getErrorMessage(error)}`);
+                    await errorSubject.next([this.params.clientId, error]);
                     return;
                 }
-                const fn = typeof upperFn === "function"
-                    ? await upperFn(this.params.clientId, this.params.agentName)
-                    : upperFn;
                 agentToolList.push({
                     ...other,
                     toolName,
@@ -3802,10 +4008,19 @@ class ClientAgent {
                 });
             }));
         }
-        const mcpToolList = await this.params.mcp.listTools(this.params.clientId);
+        let mcpToolList = [];
+        try {
+            mcpToolList = await this.params.mcp.listTools(this.params.clientId);
+        }
+        catch (error) {
+            // A throwing MCP listTools would reject the queued EXECUTE_FN and hang
+            // the pending waitForOutput: continue without MCP tools and surface the
+            // error to the caller through errorSubject.
+            console.error(`agent-swarm mcp listTools error agentName=${this.params.agentName} clientId=${this.params.clientId} error=${getErrorMessage(error)}`);
+            await errorSubject.next([this.params.clientId, error]);
+        }
         if (mcpToolList.length) {
             let commitActionFound = false;
-            let navigationFound = false;
             return agentToolList
                 .concat(mcpToolList.map((tool) => mapMcpToolCall(tool, this)))
                 .filter(({ function: { name } }) => {
@@ -3821,13 +4036,11 @@ class ClientAgent {
                 return aStarts === bStarts ? 0 : aStarts ? -1 : 1;
             })
                 .filter((tool) => {
-                const isNavigation = swarm$1.navigationSchemaService.hasTool(tool.toolName);
-                if (isNavigation) {
-                    if (navigationFound) {
-                        return false;
-                    }
-                    navigationFound = true;
-                }
+                // Do NOT collapse navigation tools to a single one: a router agent
+                // legitimately exposes several (nav-to-sales/tech/human) and the model
+                // must be able to call any of them. Only commit-action tools are
+                // limited to one, since running multiple actions in one turn is
+                // ambiguous.
                 const isCommitAction = swarm$1.actionSchemaService.hasTool(tool.toolName);
                 if (isCommitAction) {
                     if (commitActionFound) {
@@ -3839,7 +4052,6 @@ class ClientAgent {
             });
         }
         let commitActionFound = false;
-        let navigationFound = false;
         return agentToolList
             .filter(({ function: { name } }) => {
             if (!seen.has(name)) {
@@ -3854,13 +4066,8 @@ class ClientAgent {
             return aStarts === bStarts ? 0 : aStarts ? -1 : 1;
         })
             .filter((tool) => {
-            const isNavigation = swarm$1.navigationSchemaService.hasTool(tool.toolName);
-            if (isNavigation) {
-                if (navigationFound) {
-                    return false;
-                }
-                navigationFound = true;
-            }
+            // See the MCP branch above: navigation tools are not deduplicated —
+            // only commit-action tools are limited to one per turn.
             const isCommitAction = swarm$1.actionSchemaService.hasTool(tool.toolName);
             if (isCommitAction) {
                 if (commitActionFound) {
@@ -3902,7 +4109,12 @@ class ClientAgent {
      * Supports SwarmConnectionService by broadcasting agent outputs within the swarm.
      * @throws {Error} If validation fails after model resurrection, indicating an unrecoverable state.
      **/
-    async _emitOutput(mode, rawResult) {
+    async _emitOutput(mode, rawResult, outputEpoch = this._outputEpoch) {
+        if (outputEpoch !== this._outputEpoch) {
+            GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
+                this.params.logger.debug(`ClientAgent agentName=${this.params.agentName} clientId=${this.params.clientId} _emitOutput skipped for stale execution (cancelled or substituted)`, { mode, rawResult });
+            return;
+        }
         const result = await this.params.transform(rawResult, this.params.clientId, this.params.agentName);
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
             this.params.logger.debug(`ClientAgent agentName=${this.params.agentName} clientId=${this.params.clientId} _emitOutput`, { mode, result, rawResult });
@@ -3913,6 +4125,9 @@ class ClientAgent {
             if ((validation = await this.params.validate(result))) {
                 throw new Error(`agent-swarm-kit ClientAgent agentName=${this.params.agentName} clientId=${this.params.clientId} model resurrect failed: ${validation}`);
             }
+            if (outputEpoch !== this._outputEpoch) {
+                return;
+            }
             this.params.onOutput &&
                 this.params.onOutput(this.params.clientId, this.params.agentName, result);
             this.params.onAssistantMessage &&
@@ -3935,6 +4150,9 @@ class ClientAgent {
             });
             return;
         }
+        if (outputEpoch !== this._outputEpoch) {
+            return;
+        }
         this.params.onOutput &&
             this.params.onOutput(this.params.clientId, this.params.agentName, result);
         await this._outputSubject.next(result);
@@ -4028,6 +4246,16 @@ class ClientAgent {
         await this._resqueSubject.next(MODEL_RESQUE_SYMBOL);
         return placeholder;
     }
+    /**
+     * Marks in-flight executions as substituted: the swarm emitted a replacement
+     * output (ClientSwarm.emit), so results of executions started earlier must not
+     * reach _outputSubject — they would pair with the next waiter otherwise.
+     */
+    commitOutputSubstituted() {
+        GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
+            this.params.logger.debug(`ClientAgent agentName=${this.params.agentName} clientId=${this.params.clientId} commitOutputSubstituted`);
+        this._outputEpoch += 1;
+    }
     /**
      * Waits for the next output to be emitted via _outputSubject, typically after execute or run.
      * Useful for external consumers (e.g., SwarmConnectionService) awaiting agent responses.
@@ -4126,7 +4354,22 @@ class ClientAgent {
         }
         else if (GLOBAL_CONFIG.CC_RESQUE_STRATEGY === "custom") {
             console.warn(`agent-swarm model using custom resurrect for agentName=${this.params.agentName} clientId=${this.params.clientId} validation=${validation}`);
-            const output = await GLOBAL_CONFIG.CC_TOOL_CALL_EXCEPTION_CUSTOM_FUNCTION(this.params.clientId, this.params.agentName);
+            let output;
+            try {
+                output = await GLOBAL_CONFIG.CC_TOOL_CALL_EXCEPTION_CUSTOM_FUNCTION(this.params.clientId, this.params.agentName);
+            }
+            catch (error) {
+                // A throwing custom resque function must not reject the queued
+                // EXECUTE_FN: degrade to a placeholder answer instead.
+                console.error(`agent-swarm CC_TOOL_CALL_EXCEPTION_CUSTOM_FUNCTION error agentName=${this.params.agentName} error=${getErrorMessage(error)}`);
+                await errorSubject.next([this.params.clientId, error]);
+                output = {
+                    agentName: this.params.agentName,
+                    mode: "tool",
+                    role: "assistant",
+                    content: createPlaceholder(),
+                };
+            }
             this.params.completion.callbacks?.onComplete &&
                 this.params.completion.callbacks?.onComplete(args, output);
             return output;
@@ -4241,6 +4484,7 @@ class ClientAgent {
     async commitCancelOutput() {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
             this.params.logger.debug(`ClientAgent agentName=${this.params.agentName} clientId=${this.params.clientId} commitCancelOutput`);
+        this._outputEpoch += 1;
         this._toolAbortController.abort();
         await this._cancelOutputSubject.next(CANCEL_OUTPUT_SYMBOL);
         await this.params.bus.emit(this.params.clientId, {
@@ -4409,6 +4653,14 @@ class ClientAgent {
     async dispose() {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
             this.params.logger.debug(`ClientAgent agentName=${this.params.agentName} clientId=${this.params.clientId} dispose`);
+        if (this._activeExecutions > 0) {
+            // The instance is being torn down while its execution is still running
+            // (e.g. changeToAgent mid-completion). Resolve the pending waiter with an
+            // empty output and invalidate the epoch so the late completion result of
+            // the dying instance is dropped instead of poisoning the next waiter.
+            this._outputEpoch += 1;
+            await this._outputSubject.next("");
+        }
         {
             this._agentChangeSubject.unsubscribeAll();
             this._resqueSubject.unsubscribeAll();
@@ -4424,8 +4676,6 @@ class ClientAgent {
     }
 }
 
-/** Timeout duration for operator signal in milliseconds*/
-const OPERATOR_SIGNAL_TIMEOUT = 90000;
 /** Symbol representing operator timeout*/
 const OPERATOR_SIGNAL_SYMBOL = Symbol("operator-timeout");
 /**
@@ -4457,8 +4707,9 @@ class OperatorSignal {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
             this.params.logger.debug(`OperatorSignal agentName=${this.params.agentName} clientId=${this.params.clientId} dispose`);
         if (this._disposeRef) {
+            const disposeRef = this._disposeRef;
             this._disposeRef = null;
-            await this._disposeRef();
+            await disposeRef();
         }
     }
 }
@@ -4493,10 +4744,13 @@ class ClientOperator {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
             this.params.logger.debug(`ClientOperator agentName=${this.params.agentName} clientId=${this.params.clientId} execute begin`, { input, mode });
         if (mode === "tool") {
-            console.warn(`ClientOperator: execute with tool mode should not be called for clientId=${this.params.clientId} agentName=${this.params.agentName}`);
+            // A tool-mode execute reaching an operator is normal: navigation to an
+            // operator agent ends with executeForce (mode "tool"). Forward it to the
+            // human instead of returning silently — returning would leave the
+            // enclosing waitForOutput hanging forever, making the operator agent
+            // unreachable through navigation.
             GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
-                this.params.logger.debug(`ClientOperator agentName=${this.params.agentName} clientId=${this.params.clientId} execute - tool mode not supported`);
-            return;
+                this.params.logger.debug(`ClientOperator agentName=${this.params.agentName} clientId=${this.params.clientId} execute tool mode forwarded to operator`);
         }
         this._operatorSignal.sendMessage(input, this._outgoingSubject.next);
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
@@ -4513,11 +4767,11 @@ class ClientOperator {
         }
         const result = await Promise.race([
             this._outgoingSubject.toPromise(),
-            sleep(OPERATOR_SIGNAL_TIMEOUT).then(() => OPERATOR_SIGNAL_SYMBOL),
+            sleep(GLOBAL_CONFIG.CC_OPERATOR_SIGNAL_TIMEOUT).then(() => OPERATOR_SIGNAL_SYMBOL),
         ]);
         if (typeof result === "symbol") {
             GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
-                this.params.logger.debug(`ClientOperator agentName=${this.params.agentName} clientId=${this.params.clientId} waitForOutput timeout after ${OPERATOR_SIGNAL_TIMEOUT}ms`);
+                this.params.logger.debug(`ClientOperator agentName=${this.params.agentName} clientId=${this.params.clientId} waitForOutput timeout after ${GLOBAL_CONFIG.CC_OPERATOR_SIGNAL_TIMEOUT}ms`);
             await this._operatorSignal.dispose();
             return "";
         }
@@ -4624,26 +4878,26 @@ class ClientOperator {
     }
 }
 
-const METHOD_NAME$1L = "function.commit.commitToolOutput";
+const METHOD_NAME$1M = "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$1L, {
+        swarm$1.loggerService.log(METHOD_NAME$1M, {
             toolId,
             content,
             clientId,
             agentName,
         });
     // Validate the agent, session, and swarm to ensure they exist and are accessible
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1L);
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1L);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1M);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1M);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1L);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1M);
     // Check if the specified agent is still the active agent in the swarm session
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1L, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1M, clientId, swarmName);
     if (currentAgentName !== agentName) {
         // Log a skip message if the agent has changed during the operation
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
@@ -4656,7 +4910,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$1L, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitToolOutput(toolId, content, METHOD_NAME$1M, clientId, swarmName);
 });
 /**
  * Commits the output of a tool execution to the active agent in a swarm session.
@@ -4678,10 +4932,7 @@ async function commitToolOutput(toolId, content, clientId, agentName) {
     return await commitToolOutputInternal(toolId, content, clientId, agentName);
 }
 
-const disposeSubject = new Subject();
-const errorSubject = new Subject();
-
-const METHOD_NAME$1K = "function.target.execute";
+const METHOD_NAME$1L = "function.target.execute";
 /**
  * Function implementation
 */
@@ -4689,19 +4940,19 @@ const executeInternal = beginContext(async (content, clientId, agentName) => {
     const executionId = randomString();
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$1K, {
+        swarm$1.loggerService.log(METHOD_NAME$1L, {
             content,
             clientId,
             agentName,
             executionId,
         });
     // Validate the agent, session, and swarm
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1K);
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1K);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$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
-    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) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "execute" skipped due to the agent change', {
@@ -4727,7 +4978,7 @@ const executeInternal = beginContext(async (content, clientId, agentName) => {
                     errorValue = error;
                 }
             });
-            result = await swarm$1.sessionPublicService.execute(content, "tool", METHOD_NAME$1K, clientId, swarmName);
+            result = await swarm$1.sessionPublicService.execute(content, "tool", METHOD_NAME$1L, clientId, swarmName);
             unError();
             if (errorValue) {
                 throw errorValue;
@@ -4773,26 +5024,26 @@ async function execute(content, clientId, agentName) {
 }
 
 /** @private Constant defining the method name for logging and validation context*/
-const METHOD_NAME$1J = "function.commit.commitFlush";
+const METHOD_NAME$1K = "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$1J, {
+        swarm$1.loggerService.log(METHOD_NAME$1K, {
             clientId,
             agentName,
         });
     // Validate the agent exists
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1J);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1K);
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1J);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1K);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1J);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1K);
     // Check if the current agent matches the provided agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1J, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1K, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "commitFlush" skipped due to the agent change', {
@@ -4803,7 +5054,7 @@ const commitFlushInternal = beginContext(async (clientId, agentName) => {
         return;
     }
     // Commit the flush of agent history via SessionPublicService
-    await swarm$1.sessionPublicService.commitFlush(METHOD_NAME$1J, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitFlush(METHOD_NAME$1K, clientId, swarmName);
 });
 /**
  * Commits a flush of agent history for a specific client and agent in the swarm system.
@@ -4822,25 +5073,25 @@ async function commitFlush(clientId, agentName) {
     return await commitFlushInternal(clientId, agentName);
 }
 
-const METHOD_NAME$1I = "function.target.emit";
+const METHOD_NAME$1J = "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$1I, {
+        swarm$1.loggerService.log(METHOD_NAME$1J, {
             content,
             clientId,
             agentName,
         });
     // Validate the agent, session, and swarm
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1I);
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1I);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1J);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1J);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1I);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1J);
     // Check if the specified agent is still the active agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1I, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1J, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "emit" skipped due to the agent change', {
@@ -4851,21 +5102,21 @@ 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$1I, clientId, swarmName);
+    return await swarm$1.sessionPublicService.emit(content, METHOD_NAME$1J, clientId, swarmName);
 });
 /**
  * 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".
+ * This function directly emits a provided string as output from the swarm session, bypassing message execution.
+ * 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 and logs the operation if enabled. Works for any session mode.
  *
  *
  * @param {string} content - The content to be processed or stored.
  * @param {string} clientId - The unique identifier of the client session.
  * @param {AgentName} agentName - The name of the agent to use or reference.
- * @throws {Error} If the session mode is not "makeConnection", or if agent, session, or swarm validation fails.
+ * @throws {Error} If agent, session, or swarm validation fails.
  * @example
  * await emit("Direct output", "client-123", "AgentX"); // Emits "Direct output" if AgentX is active
 */
@@ -4873,22 +5124,22 @@ async function emit(content, clientId, agentName) {
     return await emitInternal(content, clientId, agentName);
 }
 
-const METHOD_NAME$1H = "function.common.getAgentName";
+const METHOD_NAME$1I = "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$1H, {
+        swarm$1.loggerService.log(METHOD_NAME$1I, {
             clientId,
         });
     // Validate the session and swarm to ensure they exist and are accessible
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1H);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1I);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1H);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1I);
     // Retrieve the active agent name via the swarm public service
-    return await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1H, clientId, swarmName);
+    return await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1I, clientId, swarmName);
 });
 /**
  * Retrieves the name of the active agent for a given client session in a swarm.
@@ -4909,26 +5160,26 @@ async function getAgentName(clientId) {
 }
 
 /** @private Constant defining the method name for logging and validation context*/
-const METHOD_NAME$1G = "function.commit.commitStopTools";
+const METHOD_NAME$1H = "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$1G, {
+        swarm$1.loggerService.log(METHOD_NAME$1H, {
             clientId,
             agentName,
         });
     // Validate the agent exists
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1G);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1H);
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1G);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1H);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1G);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1H);
     // Check if the current agent matches the provided agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1G, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1H, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "commitStopTools" skipped due to the agent change', {
@@ -4939,7 +5190,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$1G, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitStopTools(METHOD_NAME$1H, clientId, swarmName);
 });
 /**
  * Prevents the next tool from being executed for a specific client and agent in the swarm system.
@@ -5158,6 +5409,63 @@ class MCPUtils {
 */
 const MCP = new MCPUtils();
 
+/**
+ * Wraps schema observer callbacks (onExecute, onOutput, onInit, ...) so a throwing
+ * callback cannot reject the queued agent execution. ClientAgent invokes these
+ * fire-and-forget from EXECUTE_FN/RUN_FN: an uncaught throw there becomes an
+ * unhandled rejection and the pending waitForOutput hangs forever.
+ * Callbacks are observers — log the error and keep the flow running.
+ */
+const guardAgentCallbacks = (callbacks, agentName) => {
+    if (!callbacks) {
+        return {};
+    }
+    const result = {};
+    for (const [key, value] of Object.entries(callbacks)) {
+        if (typeof value !== "function") {
+            result[key] = value;
+            continue;
+        }
+        result[key] = (...args) => {
+            try {
+                const output = value(...args);
+                if (output && typeof output.catch === "function") {
+                    output.catch((error) => console.error(`agent-swarm ${key} agent callback error agentName=${agentName} error=${getErrorMessage(error)}`));
+                }
+                return output;
+            }
+            catch (error) {
+                console.error(`agent-swarm ${key} agent callback error agentName=${agentName} error=${getErrorMessage(error)}`);
+            }
+        };
+    }
+    return result;
+};
+/**
+ * Wraps a schema transformer hook (transform/map/mapToolCalls/prompt/systemDynamic).
+ * A throwing transformer is a configuration error: it is surfaced to the caller
+ * through errorSubject (session.complete/execute reject after the exchange), while
+ * the flow continues with the untouched input value — falling back to an empty
+ * result here would re-enter the resurrect path whose own transform call throws
+ * again, deadlocking the execution.
+ *
+ * @param fn - The user transformer to guard.
+ * @param name - Hook name for logging.
+ * @param agentName - Owning agent name for logging.
+ * @param getClientId - Extracts clientId from the call arguments for errorSubject.
+ * @param getFallback - Produces the fallback result from the call arguments.
+ */
+const guardAgentTransformer = (fn, name, agentName, getClientId, getFallback) => (async (...args) => {
+    try {
+        return await fn(...args);
+    }
+    catch (error) {
+        console.error(`agent-swarm ${name} hook error agentName=${agentName} error=${getErrorMessage(error)}`);
+        await errorSubject.next([getClientId(...args), error]);
+        return getFallback(...args);
+    }
+});
+
 /**
  * Service class for managing agent connections and operations in the swarm system.
  * Implements IAgent to provide an interface for agent instantiation, execution, message handling, and lifecycle management.
@@ -5246,10 +5554,12 @@ class AgentConnectionService {
             this.sessionValidationService.addAgentUsage(clientId, agentName);
             storages?.forEach((storageName) => this.storageConnectionService
                 .getStorage(clientId, storageName)
-                .waitForInit());
+                .waitForInit()
+                .catch((error) => console.error(`agent-swarm storage waitForInit error storageName=${storageName} clientId=${clientId} error=${getErrorMessage(error)}`)));
             states?.forEach((stateName) => this.stateConnectionService
                 .getStateRef(clientId, stateName)
-                .waitForInit());
+                .waitForInit()
+                .catch((error) => console.error(`agent-swarm state waitForInit error stateName=${stateName} clientId=${clientId} error=${getErrorMessage(error)}`)));
             if (operator) {
                 return new ClientOperator({
                     clientId,
@@ -5258,29 +5568,33 @@ class AgentConnectionService {
                     history,
                     logger: this.loggerService,
                     connectOperator,
-                    ...callbacks,
+                    ...guardAgentCallbacks(callbacks, agentName),
                 });
             }
             return new ClientAgent({
                 clientId,
                 agentName,
-                validate,
+                validate: guardAgentTransformer(validate, "validate", agentName, () => clientId, () => null),
                 maxToolCalls,
-                mapToolCalls,
+                mapToolCalls: guardAgentTransformer(mapToolCalls, "mapToolCalls", agentName, (_calls, callClientId) => callClientId, (calls) => calls),
                 logger: this.loggerService,
                 bus: this.busService,
                 mcp: mcp
                     ? new MergeMCP(mcp.map(this.mcpConnectionService.getMCP), agentName)
                     : new NoopMCP(agentName),
                 history,
-                prompt,
+                prompt: typeof prompt === "function"
+                    ? guardAgentTransformer(prompt, "prompt", agentName, (callClientId) => callClientId, () => "")
+                    : prompt,
                 systemStatic,
-                systemDynamic,
-                transform,
-                map,
+                systemDynamic: systemDynamic
+                    ? guardAgentTransformer(systemDynamic, "systemDynamic", agentName, (callClientId) => callClientId, () => [])
+                    : systemDynamic,
+                transform: guardAgentTransformer(transform, "transform", agentName, (_text, callClientId) => callClientId, (text) => text),
+                map: guardAgentTransformer(map, "map", agentName, (_message, callClientId) => callClientId, (message) => message),
                 tools: tools?.map(this.toolSchemaService.get),
                 completion: this.completionSchemaService.get(completionName),
-                ...callbacks,
+                ...guardAgentCallbacks(callbacks, agentName),
             });
         });
         /**
@@ -5453,12 +5767,12 @@ class AgentConnectionService {
 }
 
 /** @private Constant defining the method name for logging purposes*/
-const METHOD_NAME$1F = "function.common.getPayload";
+const METHOD_NAME$1G = "function.common.getPayload";
 /**
  * Function implementation
 */
 const getPayloadInternal = () => {
-    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$1F);
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$1G);
     if (PayloadContextService.hasContext()) {
         const { payload } = swarm$1.payloadContextService.context;
         return payload;
@@ -5507,7 +5821,16 @@ class ClientHistory {
         if (message.mode === "user" && message.role === "user") {
             message = { ...message, payload: getPayload() };
         }
-        await this.params.items.push(message, this.params.clientId, this.params.agentName);
+        try {
+            await this.params.items.push(message, this.params.clientId, this.params.agentName);
+        }
+        catch (error) {
+            // A throwing history adapter must not reject the queued EXECUTE_FN
+            // (unhandled rejection + hung waitForOutput): drop the record, surface
+            // the error through errorSubject so the caller's complete() rejects.
+            console.error(`agent-swarm history push error agentName=${this.params.agentName} clientId=${this.params.clientId} error=${getErrorMessage(error)}`);
+            await errorSubject.next([this.params.clientId, error]);
+        }
         await this.params.bus.emit(this.params.clientId, {
             type: "push",
             source: "history-bus",
@@ -5552,8 +5875,14 @@ class ClientHistory {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
             this.params.logger.debug(`ClientHistory agentName=${this.params.agentName} toArrayForRaw`);
         const result = [];
-        for await (const item of this.params.items.iterate(this.params.clientId, this.params.agentName)) {
-            result.push(item);
+        try {
+            for await (const item of this.params.items.iterate(this.params.clientId, this.params.agentName)) {
+                result.push(item);
+            }
+        }
+        catch (error) {
+            console.error(`agent-swarm history iterate error agentName=${this.params.agentName} clientId=${this.params.clientId} error=${getErrorMessage(error)}`);
+            await errorSubject.next([this.params.clientId, error]);
         }
         return result;
     }
@@ -5568,7 +5897,19 @@ class ClientHistory {
             this.params.logger.debug(`ClientHistory agentName=${this.params.agentName} toArrayForAgent`);
         const commonMessagesRaw = [];
         const systemMessagesRaw = [];
-        for await (const content of this.params.items.iterate(this.params.clientId, this.params.agentName)) {
+        const iterated = [];
+        try {
+            for await (const content of this.params.items.iterate(this.params.clientId, this.params.agentName)) {
+                iterated.push(content);
+            }
+        }
+        catch (error) {
+            // A throwing history adapter or filter must not reject getCompletion
+            // inside the queued EXECUTE_FN: continue with what was collected.
+            console.error(`agent-swarm history iterate error agentName=${this.params.agentName} clientId=${this.params.clientId} error=${getErrorMessage(error)}`);
+            await errorSubject.next([this.params.clientId, error]);
+        }
+        for (const content of iterated) {
             const message = content;
             if (message.role === "resque") {
                 commonMessagesRaw.splice(0, commonMessagesRaw.length);
@@ -5591,15 +5932,27 @@ class ClientHistory {
             }
         }
         const systemMessages = systemMessagesRaw.filter(({ agentName }) => agentName === this.params.agentName);
-        const commonMessages = commonMessagesRaw
+        const filteredCommonMessages = commonMessagesRaw
             .map(({ content, tool_calls, ...other }) => ({
             ...other,
             tool_calls,
             content: content || "",
         }))
             .filter(({ content, tool_calls }) => !!content || !!tool_calls?.length)
-            .filter(this._filterCondition)
-            .slice(-this.params.keepMessages);
+            .filter((message) => {
+            try {
+                return this._filterCondition(message);
+            }
+            catch (error) {
+                console.error(`agent-swarm history filter error agentName=${this.params.agentName} error=${getErrorMessage(error)}`);
+                return true;
+            }
+        });
+        // slice(-0) === slice(0) keeps the WHOLE array, so keepMessages=0 would keep
+        // all history instead of none — clamp explicitly to an empty window.
+        const commonMessages = this.params.keepMessages > 0
+            ? filteredCommonMessages.slice(-this.params.keepMessages)
+            : [];
         const assistantToolOutputCallSet = new Set(commonMessages
             .filter(({ tool_call_id }) => !!tool_call_id)
             .map(({ tool_call_id }) => tool_call_id));
@@ -6187,10 +6540,50 @@ class ClientSwarm {
          */
         this._cancelOutputSubject = new Subject();
         /**
-         * Waits for output from the active agent in a queued manner, delegating to WAIT_FOR_OUTPUT_FN.
-         * Ensures only one wait operation runs at a time, handling cancellation and agent changes, supporting ClientSession's output retrieval.
+         * Chain of pending waitForOutput calls, reset to a resolved promise whenever
+         * the most recently started waiter settles. See waitForOutput for the rationale.
+         */
+        this._lastOutputAwaiter = Promise.resolve();
+        /**
+         * Waiters created by waitForOutput that have not settled yet, in creation order.
+         * joinOutput attaches nested tool executions to the head of this list.
+         */
+        this._pendingOutputAwaiters = [];
+        /**
+         * Waits for output from the active agent, delegating to WAIT_FOR_OUTPUT_FN.
+         * Pending waiters run in FIFO order so each one consumes the next emitted output,
+         * but once a started waiter settles the chain is reset: a waiter that subscribed
+         * too late to observe its output stays pending without blocking waiters created
+         * afterwards. Strict sequential queueing must be avoided here — a nested tool
+         * execute whose output was already consumed would deadlock every later completion.
          */
-        this.waitForOutput = queued(async () => await WAIT_FOR_OUTPUT_FN(this));
+        this.waitForOutput = () => {
+            const currentPromise = this._lastOutputAwaiter.then(async () => await WAIT_FOR_OUTPUT_FN(this));
+            this._lastOutputAwaiter = currentPromise;
+            this._pendingOutputAwaiters.push(currentPromise);
+            const reset = () => {
+                this._lastOutputAwaiter = Promise.resolve();
+                const idx = this._pendingOutputAwaiters.indexOf(currentPromise);
+                if (idx !== -1) {
+                    this._pendingOutputAwaiters.splice(idx, 1);
+                }
+            };
+            currentPromise.then(reset, reset);
+            return currentPromise;
+        };
+        /**
+         * Awaits the same output as the oldest pending waitForOutput call, or starts a
+         * fresh wait when none is pending. Nested executions triggered from inside a tool
+         * (execute/executeForce with "tool" mode) must use this instead of waitForOutput:
+         * their emitted output resolves the parent waiter, so queueing behind it would
+         * leave the nested caller pending forever and skip the tool's onAfterCall.
+         */
+        this.joinOutput = () => {
+            if (this._pendingOutputAwaiters.length) {
+                return this._pendingOutputAwaiters[0];
+            }
+            return this.waitForOutput();
+        };
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
             this.params.logger.debug(`ClientSwarm swarmName=${this.params.swarmName} clientId=${this.params.clientId} CTOR`, {
                 params,
@@ -6204,6 +6597,13 @@ class ClientSwarm {
     async emit(message) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
             this.params.logger.debug(`ClientSwarm swarmName=${this.params.swarmName} clientId=${this.params.clientId} emit`);
+        // The emitted message substitutes the output of any in-flight execution:
+        // invalidate agents' pending emissions so a stale result cannot resolve
+        // the waiter of the next message.
+        for (const [, agent] of this._agentList) {
+            const agentRef = agent;
+            agentRef.commitOutputSubstituted?.();
+        }
         await this._emitSubject.next({
             agentName: await this.getAgentName(),
             output: message,
@@ -6231,6 +6631,13 @@ class ClientSwarm {
         if (this._navigationStack === STACK_NEED_FETCH) {
             this._navigationStack = await this.params.getNavigationStack(this.params.clientId, this.params.swarmName);
         }
+        // setAgentName pushes the NEW agent, so the top of the stack is the agent
+        // we are currently on — drop it first, otherwise "previous" would resolve
+        // to the active agent itself (self-navigation instead of going back).
+        const activeAgent = await this.getAgentName();
+        if (this._navigationStack[this._navigationStack.length - 1] === activeAgent) {
+            this._navigationStack.pop();
+        }
         const prevAgent = this._navigationStack.pop();
         await this.params.setNavigationStack(this.params.clientId, this._navigationStack, this.params.swarmName);
         return prevAgent ? prevAgent : this.params.defaultAgent;
@@ -6376,6 +6783,18 @@ class ClientSwarm {
     async dispose() {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
             this.params.logger.debug(`ClientSession clientId=${this.params.clientId} dispose`);
+        if (this._pendingOutputAwaiters.length) {
+            // Resolve in-flight waitForOutput calls with an empty output (same
+            // contract as cancelOutput) before unsubscribing — otherwise a complete()
+            // pending at dispose time would never settle.
+            const agentName = this._activeAgent === AGENT_NEED_FETCH
+                ? this.params.defaultAgent
+                : this._activeAgent;
+            await this._cancelOutputSubject.next({
+                agentName,
+                output: "",
+            });
+        }
         {
             this._agentChangedSubject.unsubscribeAll();
             this._emitSubject.unsubscribeAll();
@@ -6759,10 +7178,10 @@ class CompletionSchemaService {
                 throw new Error(`agent-swarm completion schema validation failed: missing getCompletion for completionName=${completionSchema.completionName}`);
             }
             if (completionSchema.flags && !Array.isArray(completionSchema.flags)) {
-                throw new Error(`agent-swarm completion schema validation failed: invalid flags for computeName=${completionSchema.completionName} flags=${completionSchema.flags}`);
+                throw new Error(`agent-swarm completion schema validation failed: invalid flags for completionName=${completionSchema.completionName} flags=${completionSchema.flags}`);
             }
             if (completionSchema.flags?.some((value) => typeof value !== "string")) {
-                throw new Error(`agent-swarm completion schema validation failed: invalid flags for computeName=${completionSchema.completionName} flags=[${completionSchema.flags}]`);
+                throw new Error(`agent-swarm completion schema validation failed: invalid flags for completionName=${completionSchema.completionName} flags=[${completionSchema.flags}]`);
             }
         };
         /**
@@ -6945,7 +7364,15 @@ class ClientSession {
         if (mode === "user") {
             await this.AQUIRE_LOCK(this);
         }
-        const outputAwaiter = this.params.swarm.waitForOutput();
+        // A tool-mode execute issued while a tool call is still running is a nested
+        // continuation of that execution: its output resolves the already pending
+        // waiter, so it must join it. Standalone server-side tool-mode executes keep
+        // the FIFO waitForOutput pairing.
+        const isNestedToolExecution = mode === "tool" &&
+            Object.values(this.params.swarm.params.agentMap).some((agentRef) => agentRef instanceof ClientAgent && agentRef._runningToolCalls > 0);
+        const outputAwaiter = isNestedToolExecution
+            ? this.params.swarm.joinOutput()
+            : this.params.swarm.waitForOutput();
         agent.execute(message, mode);
         let output = "";
         try {
@@ -7229,12 +7656,19 @@ class ClientSession {
             clientId: this.params.clientId,
         });
         this._notifySubject.subscribe(async (data) => {
-            await swarm$1.executionValidationService.flushCount(this.params.clientId, this.params.swarmName);
-            await connector({
-                data,
-                agentName: await this.params.swarm.getAgentName(),
-                clientId: this.params.clientId,
-            });
+            try {
+                await swarm$1.executionValidationService.flushCount(this.params.clientId, this.params.swarmName);
+                await connector({
+                    data,
+                    agentName: await this.params.swarm.getAgentName(),
+                    clientId: this.params.clientId,
+                });
+            }
+            catch (error) {
+                // A throwing connector must not reject the notify subject chain
+                // (unhandled rejection that can crash the host process).
+                console.error(`agent-swarm connector error clientId=${this.params.clientId} error=${getErrorMessage(error)}`);
+            }
         });
         return async (incoming) => {
             GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
@@ -9270,9 +9704,13 @@ class AgentValidationService {
             if (!agent) {
                 throw new Error(`agent-swarm agent ${agentName} not found source=${source}`);
             }
-            const completionSchema = this.completionSchemaService.get(agent.completion);
-            if (completionSchema.json) {
-                throw new Error(`agent-swarm agent ${agentName} completion schema is JSON source=${source}`);
+            // Operator agents may omit completion entirely (see validateShallow),
+            // so the JSON-flag check only applies when a completion is configured.
+            if (agent.completion) {
+                const completionSchema = this.completionSchemaService.get(agent.completion);
+                if (completionSchema.json) {
+                    throw new Error(`agent-swarm agent ${agentName} completion schema is JSON source=${source}`);
+                }
             }
             if (!agent.operator) {
                 this.completionValidationService.validate(agent.completion, source);
@@ -10280,12 +10718,21 @@ const WAIT_FOR_INIT_FN$1 = async (self) => {
     if (!self.params.getData) {
         return;
     }
-    const data = await self.params.getData(self.params.clientId, self.params.storageName, await self.params.getDefaultData(self.params.clientId, self.params.storageName));
-    await Promise.all(data.map(execpool(self._createEmbedding, {
-        delay: STORAGE_POOL_DELAY,
-        maxExec: GLOBAL_CONFIG.CC_STORAGE_SEARCH_POOL,
-    })));
-    self._itemMap = new Map(data.map((item) => [item.id, item]));
+    try {
+        const data = await self.params.getData(self.params.clientId, self.params.storageName, await self.params.getDefaultData(self.params.clientId, self.params.storageName));
+        await Promise.all(data.map(execpool(self._createEmbedding, {
+            delay: STORAGE_POOL_DELAY,
+            maxExec: GLOBAL_CONFIG.CC_STORAGE_SEARCH_POOL,
+        })));
+        self._itemMap = new Map(data.map((item) => [item.id, item]));
+    }
+    catch (error) {
+        // waitForInit is fired without await from AgentConnectionService.getAgent:
+        // a rejecting persistence adapter would otherwise crash the host process.
+        // Degrade to an empty storage and surface the error.
+        console.error(`agent-swarm storage init error storageName=${self.params.storageName} clientId=${self.params.clientId} error=${getErrorMessage(error)}`);
+        await errorSubject.next([self.params.clientId, error]);
+    }
 };
 /**
  * Upserts an item into the storage, updates embeddings, and persists the data via params.setData.
@@ -10449,9 +10896,11 @@ class ClientStorage {
                 total,
             });
         const indexed = new SortedArray();
-        let searchEmbeddings = await this.params.readEmbeddingCache(this.params.embedding, createSHA256Hash(search));
+        const searchHash = createSHA256Hash(search);
+        let searchEmbeddings = await this.params.readEmbeddingCache(this.params.embedding, searchHash);
         if (!searchEmbeddings) {
             searchEmbeddings = await this.params.createEmbedding(search, this.params.embedding);
+            await this.params.writeEmbeddingCache(searchEmbeddings, this.params.embedding, searchHash);
         }
         if (this.params.onCreate) {
             this.params.onCreate(search, searchEmbeddings, this.params.clientId, this.params.embedding);
@@ -11279,7 +11728,15 @@ const DISPATCH_FN = async (action, self, payload) => {
 const WAIT_FOR_INIT_FN = async (self) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
         self.params.logger.debug(`ClientState stateName=${self.params.stateName} clientId=${self.params.clientId} shared=${self.params.shared} waitForInit`);
-    self._state = await self.params.getState(self.params.clientId, self.params.stateName, await self.params.getDefaultState(self.params.clientId, self.params.stateName));
+    try {
+        self._state = await self.params.getState(self.params.clientId, self.params.stateName, await self.params.getDefaultState(self.params.clientId, self.params.stateName));
+    }
+    catch (error) {
+        // waitForInit is fired without await from AgentConnectionService.getAgent:
+        // a rejecting persistence adapter would otherwise crash the host process.
+        console.error(`agent-swarm state init error stateName=${self.params.stateName} clientId=${self.params.clientId} error=${getErrorMessage(error)}`);
+        await errorSubject.next([self.params.clientId, error]);
+    }
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
         self.params.logger.debug(`ClientState stateName=${self.params.stateName} clientId=${self.params.clientId} shared=${self.params.shared} waitForInit output`, { initialState: self._state });
     if (self.params.callbacks?.onLoad) {
@@ -11300,6 +11757,12 @@ class ClientState {
     constructor(params) {
         this.params = params;
         this.stateChanged = new Subject();
+        /**
+         * True while a queued dispatch (read/write) is executing for this instance.
+         * getState checks it to serve reentrant reads (getState inside a setState
+         * dispatchFn) without re-entering the queue, which would deadlock.
+         */
+        this._inDispatch = false;
         /**
          * The current state data, initialized as null and set during waitForInit.
          * Updated by setState and clearState, persisted via params.setState if provided.
@@ -11309,7 +11772,15 @@ class ClientState {
          * Queued dispatch function to read or write the state, delegating to DISPATCH_FN.
          * Ensures thread-safe state operations, supporting concurrent access from ClientAgent or tools.
          */
-        this.dispatch = queued(async (action, payload) => await DISPATCH_FN(action, this, payload));
+        this.dispatch = queued(async (action, payload) => {
+            this._inDispatch = true;
+            try {
+                return await DISPATCH_FN(action, this, payload);
+            }
+            finally {
+                this._inDispatch = false;
+            }
+        });
         /**
          * Waits for the state to initialize via WAIT_FOR_INIT_FN, ensuring it’s only called once using singleshot.
          * Loads the initial state into _state, supporting StateConnectionService’s lifecycle management.
@@ -11398,7 +11869,14 @@ class ClientState {
     async getState() {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
             this.params.logger.debug(`ClientState stateName=${this.params.stateName} clientId=${this.params.clientId} shared=${this.params.shared} getState`);
-        await this.dispatch("read");
+        // Reads normally go through the dispatch queue to observe writes in order.
+        // A read issued from INSIDE a running write (getState within a setState
+        // dispatchFn) would deadlock behind that write, so _inDispatch lets such a
+        // reentrant read return the current field directly.
+        if (this._inDispatch) ;
+        else {
+            await this.dispatch("read");
+        }
         if (this.params.callbacks?.onRead) {
             this.params.callbacks.onRead(this._state, this.params.clientId, this.params.stateName);
         }
@@ -11702,8 +12180,27 @@ class StatePublicService {
 }
 
 /**
- * Service class implementing the IBus interface to manage event subscriptions and emissions in the swarm system.
- * Provides methods to subscribe to events (subscribe, once), emit events (emit, commitExecutionBegin, commitExecutionEnd), and dispose of subscriptions (dispose), using a memoized Subject per clientId and EventSource.
+ * Wraps a bus listener so its exceptions cannot escape into the emit path.
+ * ClientAgent awaits bus.emit inside executions: a throwing subscriber would
+ * otherwise surface as an unhandled rejection (crashing the host process on
+ * modern Node) or reject the execution itself.
+ */
+const GUARD_LISTENER_FN = (fn, clientId, source) => (event) => {
+    try {
+        const output = fn(event);
+        if (output &&
+            typeof output.catch === "function") {
+            output.catch((error) => console.error(`agent-swarm bus listener error clientId=${clientId} source=${source} error=${getErrorMessage(error)}`));
+        }
+        return output;
+    }
+    catch (error) {
+        console.error(`agent-swarm bus listener error clientId=${clientId} source=${source} error=${getErrorMessage(error)}`);
+    }
+};
+/**
+ * Service class implementing the IBus interface to manage event subscriptions and emissions in the swarm system.
+ * Provides methods to subscribe to events (subscribe, once), emit events (emit, commitExecutionBegin, commitExecutionEnd), and dispose of subscriptions (dispose), using a memoized Subject per clientId and EventSource.
  * Integrates with ClientAgent (e.g., execution events in EXECUTE_FN), PerfService (e.g., execution tracking via emit), and DocService (e.g., performance logging), leveraging LoggerService for info-level logging and SessionValidationService for session validation.
  * Supports wildcard subscriptions (clientId="*") and execution-specific event aliases, enhancing event-driven communication across the system.
 */
@@ -11755,7 +12252,7 @@ class BusService {
                 this._eventWildcardMap.set(source, true);
             }
             this._eventSourceSet.add(source);
-            return this.getEventSubject(clientId, source).subscribe(fn);
+            return this.getEventSubject(clientId, source).subscribe(GUARD_LISTENER_FN(fn, clientId, source));
         };
         /**
          * Subscribes to a single event for a specific client and event source, invoking the callback once when the filter condition is met.
@@ -11773,7 +12270,9 @@ class BusService {
                 this._eventWildcardMap.set(source, true);
             }
             this._eventSourceSet.add(source);
-            return this.getEventSubject(clientId, source).filter(filterFn).once(fn);
+            return this.getEventSubject(clientId, source)
+                .filter(filterFn)
+                .once(GUARD_LISTENER_FN(fn, clientId, source));
         };
         /**
          * Emits an event for a specific client, broadcasting to subscribers of the event’s source, including wildcard subscribers.
@@ -12738,7 +13237,7 @@ class DocService {
                             }
                             {
                                 result.push("");
-                                result.push(`*Required:* [${fn.parameters.required.includes(key) ? "x" : " "}]`);
+                                result.push(`*Required:* [${fn.parameters.required?.includes(key) ? "x" : " "}]`);
                             }
                         });
                         if (!entries.length) {
@@ -13579,7 +14078,7 @@ class MemorySchemaService {
  * console.log(msToTime(3600000));  // "01:00:00.0"
  * console.log(msToTime(61000));    // "00:01:01.0"
  * console.log(msToTime(500));      // "00:00:00.500"
- * console.log(msToTime(0));        // ""
+ * console.log(msToTime(0));        // "00:00:00.0"
  *
  * @example
  * // Edge cases
@@ -13591,8 +14090,7 @@ class MemorySchemaService {
  * - Breaks down milliseconds into hours, minutes, seconds, and remaining milliseconds using integer division and modulo operations.
  * - Pads hours, minutes, and seconds with leading zeros if they are single-digit (e.g., "5" becomes "05").
  * - Includes milliseconds with no leading zeros, fixed to zero decimal places for simplicity (e.g., "500" not "500.0").
- * - Omits leading components (hours or minutes) if they are zero, but always includes seconds and milliseconds if any time is present.
- * - Returns an empty string for an input of 0, treating it as no duration.
+ * - Always includes all components, so an input of 0 yields "00:00:00.0".
  * Useful in the agent swarm system for logging execution times, profiling operations, or displaying human-readable durations.
  *
  * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toFixed|Number.toFixed}
@@ -14432,6 +14930,15 @@ class ClientPolicy {
          * Updated by banClient and unbanClient, persisted if params.setBannedClients is provided.
          */
         this._banSet = BAN_NEED_FETCH;
+        /**
+         * Serializes the read-modify-write of _banSet shared by banClient/unbanClient.
+         * Without it two concurrent bans of different clients both read the same ban
+         * set, each adds only its own client, and the later setBannedClients overwrites
+         * the earlier one — one ban is silently lost in memory and in the persisted
+         * store. queued() runs the mutations one at a time so each observes the result
+         * of the previous one.
+         */
+        this._banQueue = queued(async (fn) => await fn());
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
             this.params.logger.debug(`ClientPolicy policyName=${this.params.policyName} CTOR`, {
                 params,
@@ -14589,16 +15096,18 @@ class ClientPolicy {
             },
             clientId,
         });
-        if (this._banSet === BAN_NEED_FETCH) {
-            this._banSet = new Set(await this.params.getBannedClients(this.params.policyName, swarmName));
-        }
-        if (this._banSet.has(clientId)) {
-            return;
-        }
-        this._banSet = new Set(this._banSet).add(clientId);
-        if (this.params.setBannedClients) {
-            await this.params.setBannedClients([...this._banSet], this.params.policyName, swarmName);
-        }
+        await this._banQueue(async () => {
+            if (this._banSet === BAN_NEED_FETCH) {
+                this._banSet = new Set(await this.params.getBannedClients(this.params.policyName, swarmName));
+            }
+            if (this._banSet.has(clientId)) {
+                return;
+            }
+            this._banSet = new Set(this._banSet).add(clientId);
+            if (this.params.setBannedClients) {
+                await this.params.setBannedClients([...this._banSet], this.params.policyName, swarmName);
+            }
+        });
     }
     /**
      * Unbans a client, removing them from the ban set and persisting the change if params.setBannedClients is provided.
@@ -14625,20 +15134,22 @@ class ClientPolicy {
             },
             clientId,
         });
-        if (this._banSet === BAN_NEED_FETCH) {
-            this._banSet = new Set(await this.params.getBannedClients(this.params.policyName, swarmName));
-        }
-        if (!this._banSet.has(clientId)) {
-            return;
-        }
-        {
-            const banSet = new Set(this._banSet);
-            banSet.delete(clientId);
-            this._banSet = banSet;
-        }
-        if (this.params.setBannedClients) {
-            await this.params.setBannedClients([...this._banSet], this.params.policyName, swarmName);
-        }
+        await this._banQueue(async () => {
+            if (this._banSet === BAN_NEED_FETCH) {
+                this._banSet = new Set(await this.params.getBannedClients(this.params.policyName, swarmName));
+            }
+            if (!this._banSet.has(clientId)) {
+                return;
+            }
+            {
+                const banSet = new Set(this._banSet);
+                banSet.delete(clientId);
+                this._banSet = banSet;
+            }
+            if (this.params.setBannedClients) {
+                await this.params.setBannedClients([...this._banSet], this.params.policyName, swarmName);
+            }
+        });
     }
 }
 
@@ -15111,7 +15622,16 @@ class ClientMCP {
         if (this.params.callbacks?.onList) {
             this.params.callbacks.onList(clientId);
         }
-        const toolMap = await this.fetchTools(clientId);
+        let toolMap;
+        try {
+            toolMap = await this.fetchTools(clientId);
+        }
+        catch (error) {
+            // Never cache a rejected fetch: the memoized promise would keep this
+            // client permanently broken even after the MCP recovers.
+            this.fetchTools.clear(clientId);
+            throw error;
+        }
         return Array.from(toolMap.values());
     }
     /**
@@ -15123,7 +15643,14 @@ class ClientMCP {
                 toolName,
                 clientId,
             });
-        const toolMap = await this.fetchTools(clientId);
+        let toolMap;
+        try {
+            toolMap = await this.fetchTools(clientId);
+        }
+        catch (error) {
+            this.fetchTools.clear(clientId);
+            throw error;
+        }
         return toolMap.has(toolName);
     }
     /**
@@ -15209,12 +15736,13 @@ class MCPConnectionService {
         this.dispose = async (clientId) => {
             GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO &&
                 this.loggerService.info(`mcpConnectionService dispose`, { clientId });
-            const key = `${this.methodContextService.context.clientId}-${this.methodContextService.context.agentName}`;
+            const key = `${this.methodContextService.context.mcpName}`;
             if (!this.getMCP.has(key)) {
                 return;
             }
+            // The ClientMCP instance is shared across clients (memoized by mcpName),
+            // so only the client-scoped resources are released; the instance stays cached.
             await this.getMCP(this.methodContextService.context.mcpName).dispose(clientId);
-            this.getMCP.clear(clientId);
         };
     }
     /**
@@ -16112,7 +16640,7 @@ class SharedComputeConnectionService {
          * @throws {Error} If the compute is not marked as shared.
          */
         this.getComputeRef = memoize(([computeName]) => `${computeName}`, (computeName) => {
-            const { getComputeData, dependsOn, middlewares = [], callbacks, shared = false, } = this.computeSchemaService.get(computeName);
+            const { getComputeData, dependsOn = [], middlewares = [], callbacks, shared = false, } = this.computeSchemaService.get(computeName);
             if (!shared) {
                 throw new Error(`agent-swarm compute not shared computeName=${computeName}`);
             }
@@ -17095,14 +17623,14 @@ const swarm = {
 init();
 var swarm$1 = swarm;
 
-const METHOD_NAME$1E = "cli.dumpDocs";
+const METHOD_NAME$1F = "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$1E, {
+        swarm$1.loggerService.log(METHOD_NAME$1F, {
             dirName,
         });
     if (PlantUML) {
@@ -17112,10 +17640,10 @@ const dumpDocs = beginContext((prefix = "swarm", dirName = "./docs/chat", PlantU
     }
     swarm$1.agentValidationService
         .getAgentList()
-        .forEach((agentName) => swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1E));
+        .forEach((agentName) => swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1F));
     swarm$1.swarmValidationService
         .getSwarmList()
-        .forEach((swarmName) => swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1E));
+        .forEach((swarmName) => swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1F));
     swarm$1.agentValidationService.getAgentList().forEach((agentName) => {
         const { dependsOn } = swarm$1.agentSchemaService.get(agentName);
         if (!dependsOn) {
@@ -17124,39 +17652,39 @@ const dumpDocs = beginContext((prefix = "swarm", dirName = "./docs/chat", PlantU
     });
     swarm$1.outlineValidationService
         .getOutlineList()
-        .forEach((swarmName) => swarm$1.outlineValidationService.validate(swarmName, METHOD_NAME$1E));
+        .forEach((swarmName) => swarm$1.outlineValidationService.validate(swarmName, METHOD_NAME$1F));
     return swarm$1.docService.dumpDocs(prefix, dirName, sanitizeMarkdown);
 });
 
-const METHOD_NAME$1D = "cli.dumpAgent";
+const METHOD_NAME$1E = "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$1D, {
+        swarm$1.loggerService.log(METHOD_NAME$1E, {
             agentName,
         });
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1D);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1E);
     return swarm$1.agentMetaService.toUML(agentName, withSubtree);
 });
 
-const METHOD_NAME$1C = "cli.dumpSwarm";
+const METHOD_NAME$1D = "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$1C, {
+        swarm$1.loggerService.log(METHOD_NAME$1D, {
             swarmName,
         });
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1C);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1D);
     return swarm$1.swarmMetaService.toUML(swarmName);
 });
 
-const METHOD_NAME$1B = "cli.dumpPerfomance";
+const METHOD_NAME$1C = "cli.dumpPerfomance";
 const METHOD_NAME_INTERNAL$1 = "cli.dumpPerfomance.internal";
 const METHOD_NAME_INTERVAL = "cli.dumpPerfomance.interval";
 /**
@@ -17173,7 +17701,7 @@ const dumpPerfomanceInternal = beginContext(async (dirName = "./dump/agent/meta"
  *
 */
 const dumpPerfomance = async (dirName = "./dump/agent/meta") => {
-    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$1B);
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$1C);
     await dumpPerfomanceInternal(dirName);
 };
 /**
@@ -17222,10 +17750,19 @@ const listenExecutionEvent = beginContext((clientId, fn) => {
     // Validate the client ID
     validateClientId$h(clientId);
     // Subscribe to execution events with a queued callback
-    return swarm$1.busService.subscribe(clientId, "execution-bus", queued(async (e) => await fn(e)));
+    return swarm$1.busService.subscribe(clientId, "execution-bus", queued(async (e) => {
+        try {
+            // A throwing listener must not reject the queued chain: that surfaces
+            // as an unhandled rejection and can crash the host process.
+            return await fn(e);
+        }
+        catch (error) {
+            console.error(`agent-swarm event listener error source=listenExecutionEvent error=${getErrorMessage(error)}`);
+        }
+    }));
 });
 
-const METHOD_NAME$1A = "cli.dumpClientPerformance";
+const METHOD_NAME$1B = "cli.dumpClientPerformance";
 const METHOD_NAME_INTERNAL = "cli.dumpClientPerformance.internal";
 const METHOD_NAME_EXECUTE = "cli.dumpClientPerformance.execute";
 /**
@@ -17243,7 +17780,7 @@ const dumpClientPerformanceInternal = beginContext(async (clientId, dirName = ".
  *
 */
 const dumpClientPerformance = async (clientId, dirName = "./dump/agent/client") => {
-    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$1A);
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$1B);
     await dumpClientPerformanceInternal(clientId, dirName);
 };
 /**
@@ -17391,24 +17928,24 @@ const dumpAdvisorResult = async (resultId, content) => {
 };
 
 /** @private Constant defining the method name for logging and validation context*/
-const METHOD_NAME$1z = "function.commit.commitFlushForce";
+const METHOD_NAME$1A = "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$1z, {
+        swarm$1.loggerService.log(METHOD_NAME$1A, {
             clientId,
-            METHOD_NAME: METHOD_NAME$1z,
+            METHOD_NAME: METHOD_NAME$1A,
         });
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1z);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1A);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1z);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1A);
     // Commit the flush of agent history via SessionPublicService without agent checks
-    await swarm$1.sessionPublicService.commitFlush(METHOD_NAME$1z, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitFlush(METHOD_NAME$1A, clientId, swarmName);
 });
 /**
  * Forcefully commits a flush of agent history for a specific client in the swarm system, without checking the active agent.
@@ -17427,24 +17964,24 @@ async function commitFlushForce(clientId) {
     return await commitFlushForceInternal(clientId);
 }
 
-const METHOD_NAME$1y = "function.commit.commitToolOutputForce";
+const METHOD_NAME$1z = "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$1y, {
+        swarm$1.loggerService.log(METHOD_NAME$1z, {
             toolId,
             content,
             clientId,
         });
     // Validate the session and swarm to ensure they exist and are accessible
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1y);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1z);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1y);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1z);
     // 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$1y, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitToolOutput(toolId, content, METHOD_NAME$1z, clientId, swarmName);
 });
 /**
  * Commits the output of a tool execution to the active agent in a swarm session without checking the active agent.
@@ -17469,15 +18006,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$1x = "function.common.hasNavigation";
+const METHOD_NAME$1y = "function.common.hasNavigation";
 /**
  * Function implementation
 */
 const hasNavigationInternal = async (clientId, agentName) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$1x, { clientId });
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1x);
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1x);
+        swarm$1.loggerService.log(METHOD_NAME$1y, { clientId });
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1y);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1y);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     return swarm$1.navigationValidationService
         .getNavigationRoute(clientId, swarmName)
@@ -17494,14 +18031,14 @@ async function hasNavigation(clientId, agentName) {
     return await hasNavigationInternal(clientId, agentName);
 }
 
-const METHOD_NAME$1w = "function.history.getRawHistory";
+const METHOD_NAME$1x = "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$1w, {
+        swarm$1.loggerService.log(METHOD_NAME$1x, {
             clientId,
         });
     // Validate the session and swarm
@@ -17529,21 +18066,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$1w);
+    return await getRawHistoryInternal(clientId, METHOD_NAME$1x);
 }
 
-const METHOD_NAME$1v = "function.history.getLastUserMessage";
+const METHOD_NAME$1w = "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$1v, {
+        swarm$1.loggerService.log(METHOD_NAME$1w, {
             clientId,
         });
     // Fetch raw history and find the last user message
-    const history = await getRawHistoryInternal(clientId, METHOD_NAME$1v);
+    const history = await getRawHistoryInternal(clientId, METHOD_NAME$1w);
     const last = history.findLast(({ role, mode }) => role === "user" && mode === "user");
     return last?.content ? last.content : null;
 });
@@ -17565,7 +18102,7 @@ async function getLastUserMessage(clientId) {
     return await getLastUserMessageInternal(clientId);
 }
 
-const METHOD_NAME$1u = "function.navigate.changeToDefaultAgent";
+const METHOD_NAME$1v = "function.navigate.changeToDefaultAgent";
 /**
  * Creates a change agent function with time-to-live (TTL) and queuing capabilities for switching to the default agent.
  *
@@ -17586,7 +18123,7 @@ const createChangeToDefaultAgent = memoize(([clientId]) => `${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$1u, clientId, swarmName);
+        const agentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1v, 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));
@@ -17613,20 +18150,20 @@ const createGc$3 = 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$1u, {
+        swarm$1.loggerService.log(METHOD_NAME$1v, {
             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$1u);
-        swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1u);
+        swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1v);
+        swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1v);
     }
     // Execute the agent change with TTL and queuing
     const run = await createChangeToDefaultAgent(clientId);
     createGc$3();
-    return await run(METHOD_NAME$1u, agentName, swarmName);
+    return await run(METHOD_NAME$1v, agentName, swarmName);
 });
 /**
  * Navigates back to the default agent for a given client session in a swarm.
@@ -17645,44 +18182,44 @@ async function changeToDefaultAgent(clientId) {
     return await changeToDefaultAgentInternal(clientId);
 }
 
-const METHOD_NAME$1t = "function.target.emitForce";
+const METHOD_NAME$1u = "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$1t, {
+        swarm$1.loggerService.log(METHOD_NAME$1u, {
             content,
             clientId,
         });
     // Validate the session and swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1t);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1u);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1t);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1u);
     // Emit the content directly via the session public service
-    return await swarm$1.sessionPublicService.emit(content, METHOD_NAME$1t, clientId, swarmName);
+    return await swarm$1.sessionPublicService.emit(content, METHOD_NAME$1u, clientId, swarmName);
 });
 /**
  * Emits a string as model output without executing an incoming message or checking the active agent.
  *
  * This function directly emits a provided string as output from the swarm session, bypassing message execution and agent activity checks.
- * It is designed exclusively for sessions established via `makeConnection`, ensuring compatibility with its connection model.
- * The execution is wrapped in `beginContext` for a clean environment, validates the session and swarm, and throws an error if the session mode
- * is not "makeConnection". The operation is logged if enabled, and resolves when the content is successfully emitted.
+ * Unlike `emit`, it does not verify that a specific agent is still active, ensuring emission even after navigation.
+ * The execution is wrapped in `beginContext` for a clean environment, validates the session and swarm,
+ * logs the operation if enabled, and resolves when the content is successfully emitted. Works for any session mode.
  *
  *
  * @param {string} content - The content to be processed or stored.
  * @param {string} clientId - The unique identifier of the client session.
- * @throws {Error} If the session mode is not "makeConnection", or if session or swarm validation fails.
+ * @throws {Error} If session or swarm validation fails.
  * @example
- * await emitForce("Direct output", "client-123"); // Emits "Direct output" in a makeConnection session
+ * await emitForce("Direct output", "client-123"); // Emits "Direct output" regardless of the active agent
 */
 async function emitForce(content, clientId) {
     return await emitForceInternal(content, clientId);
 }
 
-const METHOD_NAME$1s = "function.target.executeForce";
+const METHOD_NAME$1t = "function.target.executeForce";
 /**
  * Function implementation
 */
@@ -17690,15 +18227,15 @@ const executeForceInternal = beginContext(async (content, clientId) => {
     const executionId = randomString();
     // 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,
             executionId,
         });
     // 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);
     // Execute the command within an execution context with performance tracking
     return ExecutionContextService.runInContext(async () => {
         let isFinished = false;
@@ -17712,7 +18249,7 @@ const executeForceInternal = beginContext(async (content, clientId) => {
                     errorValue = error;
                 }
             });
-            result = await swarm$1.sessionPublicService.execute(content, "tool", METHOD_NAME$1s, clientId, swarmName);
+            result = await swarm$1.sessionPublicService.execute(content, "tool", METHOD_NAME$1t, clientId, swarmName);
             unError();
             if (errorValue) {
                 throw errorValue;
@@ -17754,24 +18291,24 @@ async function executeForce(content, clientId) {
 }
 
 /** @private Constant defining the method name for logging and validation context*/
-const METHOD_NAME$1r = "function.commit.commitStopToolsForce";
+const METHOD_NAME$1s = "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$1r, {
+        swarm$1.loggerService.log(METHOD_NAME$1s, {
             clientId,
-            METHOD_NAME: METHOD_NAME$1r,
+            METHOD_NAME: METHOD_NAME$1s,
         });
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1r);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1s);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1r);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1s);
     // Commit the stop of the next tool execution via SessionPublicService without agent checks
-    await swarm$1.sessionPublicService.commitStopTools(METHOD_NAME$1r, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitStopTools(METHOD_NAME$1s, clientId, swarmName);
 });
 /**
  * Forcefully prevents the next tool from being executed for a specific client in the swarm system, without checking the active agent.
@@ -17790,7 +18327,7 @@ async function commitStopToolsForce(clientId) {
     return await commitStopToolsForceInternal(clientId);
 }
 
-const METHOD_NAME$1q = "function.template.navigateToTriageAgent";
+const METHOD_NAME$1r = "function.template.navigateToTriageAgent";
 /**
  * Will send tool output directly to the model without any additions
 */
@@ -17832,7 +18369,7 @@ const createNavigateToTriageAgent = ({ flushMessage, beforeNavigate, lastMessage
      */
     return beginContext(async (toolId, clientId) => {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-            swarm$1.loggerService.log(METHOD_NAME$1q, {
+            swarm$1.loggerService.log(METHOD_NAME$1r, {
                 clientId,
                 toolId,
             });
@@ -17846,7 +18383,7 @@ const createNavigateToTriageAgent = ({ flushMessage, beforeNavigate, lastMessage
             beforeNavigate && await beforeNavigate(clientId, lastMessage, lastAgent, defaultAgent);
             await commitToolOutputForce(toolId, typeof toolOutputAccept === "string"
                 ? toolOutputAccept
-                : await toolOutputAccept(clientId, lastAgent), clientId);
+                : await toolOutputAccept(clientId, defaultAgent), clientId);
             await changeToDefaultAgent(clientId);
             await executeForce(lastMessage, clientId);
             return;
@@ -17867,7 +18404,7 @@ const createNavigateToTriageAgent = ({ flushMessage, beforeNavigate, lastMessage
     });
 };
 
-const METHOD_NAME$1p = "function.navigate.changeToAgent";
+const METHOD_NAME$1q = "function.navigate.changeToAgent";
 /**
  * Creates a change agent function with time-to-live (TTL) and queuing capabilities.
  *
@@ -17889,7 +18426,7 @@ const createChangeToAgent = memoize(([clientId]) => `${clientId}`, (clientId) =>
     }));
     {
         // Dispose of the current agent's resources and set up the new agent
-        const agentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1p, clientId, swarmName);
+        const agentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1q, 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));
@@ -17916,16 +18453,16 @@ const createGc$2 = 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$1p, {
+        swarm$1.loggerService.log(METHOD_NAME$1q, {
             agentName,
             clientId,
         });
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     {
         // Validate session, agent, and dependencies
-        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);
+        swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1q);
+        swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1q);
+        const activeAgent = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1q, clientId, swarmName);
         if (!swarm$1.agentValidationService.hasDependency(activeAgent, agentName)) {
             console.error(`agent-swarm missing dependency detected for activeAgent=${activeAgent} dependencyAgent=${agentName}`);
         }
@@ -17943,7 +18480,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$1p, agentName, swarmName);
+    return await run(METHOD_NAME$1q, agentName, swarmName);
 });
 /**
  * Changes the active agent for a given client session in a swarm.
@@ -17963,7 +18500,7 @@ async function changeToAgent(agentName, clientId) {
     return await changeToAgentInternal(agentName, clientId);
 }
 
-const METHOD_NAME$1o = "function.template.navigateToAgent";
+const METHOD_NAME$1p = "function.template.navigateToAgent";
 /**
  * Will send tool output directly to the model without any additions
 */
@@ -18019,7 +18556,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$1o, {
+            swarm$1.loggerService.log(METHOD_NAME$1p, {
                 clientId,
                 toolId,
             });
@@ -18057,7 +18594,7 @@ const createNavigateToAgent = ({ beforeNavigate, lastMessage: lastMessageFn = DE
     });
 };
 
-const METHOD_NAME$1n = "function.template.commitAction";
+const METHOD_NAME$1o = "function.template.commitAction";
 /**
  * Creates a commit action handler that executes actions and modifies system state (WRITE pattern).
  *
@@ -18106,7 +18643,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$1n, {
+            swarm$1.loggerService.log(METHOD_NAME$1o, {
                 clientId,
                 toolId,
                 agentName,
@@ -18200,7 +18737,7 @@ const createCommitAction = ({ validateParams, executeAction, emptyContent, fallb
     });
 };
 
-const METHOD_NAME$1m = "function.template.fetchInfo";
+const METHOD_NAME$1n = "function.template.fetchInfo";
 /**
  * Default message when content is empty.
  */
@@ -18246,7 +18783,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$1m, {
+            swarm$1.loggerService.log(METHOD_NAME$1n, {
                 clientId,
                 toolId,
                 agentName,
@@ -18257,7 +18794,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$1m} skipped due to agent change`, {
+                swarm$1.loggerService.log(`${METHOD_NAME$1n} skipped due to agent change`, {
                     currentAgentName,
                     agentName,
                     clientId,
@@ -18292,14 +18829,14 @@ const createFetchInfo = ({ fetchContent, fallback, emptyContent = DEFAULT_EMPTY_
     });
 };
 
-const METHOD_NAME$1l = "function.setup.addTool";
+const METHOD_NAME$1m = "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$1l, {
+        swarm$1.loggerService.log(METHOD_NAME$1m, {
             toolSchema,
         });
     // Register the tool in the validation and schema services
@@ -18333,12 +18870,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$1k = "function.alias.addAgentNavigation";
+const METHOD_NAME$1l = "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$1k);
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$1l);
     const navigate = createNavigateToAgent(navigateProps);
     const toolSchema = addTool({
         toolName,
@@ -18377,12 +18914,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$1j = "function.alias.addTriageNavigation";
+const METHOD_NAME$1k = "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$1j);
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$1k);
     const navigate = createNavigateToTriageAgent(navigateProps);
     const toolSchema = addTool({
         toolName,
@@ -18421,12 +18958,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$1i = "function.alias.addCommitAction";
+const METHOD_NAME$1j = "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$1i);
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$1j);
     const action = createCommitAction(actionProps);
     const toolSchema = addTool({
         toolName,
@@ -18503,12 +19040,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$1h = "function.alias.addFetchInfo";
+const METHOD_NAME$1i = "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$1h);
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$1i);
     const fetch = createFetchInfo(fetchProps);
     const toolSchema = addTool({
         toolName,
@@ -18574,13 +19111,13 @@ function addFetchInfo(params) {
 }
 
 /** @constant {string} METHOD_NAME - The name of the method used for logging*/
-const METHOD_NAME$1g = "function.setup.addAdvisor";
+const METHOD_NAME$1h = "function.setup.addAdvisor";
 /**
  * Function implementation
 */
 const addAdvisorInternal = beginContext((advisorSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$1g, {
+        swarm$1.loggerService.log(METHOD_NAME$1h, {
             advisorSchema,
         });
     swarm$1.advisorValidationService.addAdvisor(advisorSchema.advisorName, advisorSchema);
@@ -18691,14 +19228,14 @@ const mapAgentSchema = ({ system, systemDynamic, systemStatic, ...schema }) => r
         : systemDynamic,
 });
 
-const METHOD_NAME$1f = "function.setup.addAgent";
+const METHOD_NAME$1g = "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$1f, {
+        swarm$1.loggerService.log(METHOD_NAME$1g, {
             agentSchema: publicAgentSchema,
         });
     const agentSchema = mapAgentSchema(publicAgentSchema);
@@ -18734,8 +19271,26 @@ function addAgent(agentSchema) {
  * Also removes any undefined properties from the resulting schema object.
  *
 */
-const mapCompletionSchema = ({ getCompletion, ...schema }) => removeUndefined({
+const mapCompletionSchema = ({ getCompletion, callbacks, ...schema }) => removeUndefined({
     ...schema,
+    callbacks: callbacks
+        ? {
+            ...callbacks,
+            onComplete: callbacks.onComplete
+                ? (...args) => {
+                    try {
+                        // Observer callback: a throw here would reject getCompletion
+                        // inside the queued EXECUTE_FN and hang the pending
+                        // waitForOutput of the execution.
+                        return callbacks.onComplete(...args);
+                    }
+                    catch (error) {
+                        console.error(`agent-swarm onComplete completion callback error completionName=${schema.completionName} error=${getErrorMessage(error)}`);
+                    }
+                }
+                : undefined,
+        }
+        : undefined,
     getCompletion: getCompletion
         ? async (args) => {
             try {
@@ -18757,14 +19312,14 @@ const mapCompletionSchema = ({ getCompletion, ...schema }) => removeUndefined({
         : undefined,
 });
 
-const METHOD_NAME$1e = "function.setup.addCompletion";
+const METHOD_NAME$1f = "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$1e, {
+        swarm$1.loggerService.log(METHOD_NAME$1f, {
             completionSchema: completionPublicSchema,
         });
     const completionSchema = mapCompletionSchema(completionPublicSchema);
@@ -18794,14 +19349,14 @@ function addCompletion(completionSchema) {
     return addCompletionInternal(completionSchema);
 }
 
-const METHOD_NAME$1d = "function.setup.addSwarm";
+const METHOD_NAME$1e = "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$1d, {
+        swarm$1.loggerService.log(METHOD_NAME$1e, {
             swarmSchema,
         });
     // Register the swarm in the validation and schema services
@@ -18830,13 +19385,13 @@ function addSwarm(swarmSchema) {
     return addSwarmInternal(swarmSchema);
 }
 
-const METHOD_NAME$1c = "function.setup.addMCP";
+const METHOD_NAME$1d = "function.setup.addMCP";
 /**
  * Function implementation
 */
 const addMCPInternal = beginContext((mcpSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$1c, {
+        swarm$1.loggerService.log(METHOD_NAME$1d, {
             mcpSchema,
         });
     swarm$1.mcpValidationService.addMCP(mcpSchema.mcpName, mcpSchema);
@@ -18851,14 +19406,14 @@ function addMCP(mcpSchema) {
     return addMCPInternal(mcpSchema);
 }
 
-const METHOD_NAME$1b = "function.setup.addState";
+const METHOD_NAME$1c = "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$1b, {
+        swarm$1.loggerService.log(METHOD_NAME$1c, {
             stateSchema,
         });
     // Register the policy with StateValidationService for runtime validation
@@ -18869,7 +19424,8 @@ const addStateInternal = beginContext((stateSchema) => {
     if (stateSchema.shared) {
         swarm$1.sharedStateConnectionService
             .getStateRef(stateSchema.stateName)
-            .waitForInit();
+            .waitForInit()
+            .catch((error) => console.error(`agent-swarm shared state waitForInit error error=${getErrorMessage(error)}`));
     }
     // Return the state's name as confirmation of registration
     return stateSchema.stateName;
@@ -18896,14 +19452,14 @@ function addState(stateSchema) {
     return addStateInternal(stateSchema);
 }
 
-const METHOD_NAME$1a = "function.setup.addEmbedding";
+const METHOD_NAME$1b = "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$1a, {
+        swarm$1.loggerService.log(METHOD_NAME$1b, {
             embeddingSchema,
         });
     // Register the embedding in the validation and schema services
@@ -18932,14 +19488,14 @@ function addEmbedding(embeddingSchema) {
     return addEmbeddingInternal(embeddingSchema);
 }
 
-const METHOD_NAME$19 = "function.setup.addStorage";
+const METHOD_NAME$1a = "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$19, {
+        swarm$1.loggerService.log(METHOD_NAME$1a, {
             storageSchema,
         });
     // Register the storage in the validation and schema services
@@ -18949,7 +19505,8 @@ const addStorageInternal = beginContext((storageSchema) => {
     if (storageSchema.shared) {
         swarm$1.sharedStorageConnectionService
             .getStorage(storageSchema.storageName)
-            .waitForInit();
+            .waitForInit()
+            .catch((error) => console.error(`agent-swarm shared storage waitForInit error error=${getErrorMessage(error)}`));
     }
     // Return the storage's name as confirmation of registration
     return storageSchema.storageName;
@@ -18977,14 +19534,14 @@ function addStorage(storageSchema) {
 }
 
 /** @private Constant defining the method name for logging and validation context*/
-const METHOD_NAME$18 = "function.setup.addPolicy";
+const METHOD_NAME$19 = "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$18, {
+        swarm$1.loggerService.log(METHOD_NAME$19, {
             policySchema,
         });
     // Register the policy with PolicyValidationService for runtime validation
@@ -19045,13 +19602,13 @@ function addCompute(computeSchema) {
  * Method name for the addPipeline operation.
  * @private
 */
-const METHOD_NAME$17 = "function.setup.addPipeline";
+const METHOD_NAME$18 = "function.setup.addPipeline";
 /**
  * Function implementation
 */
 const addPipelineInternal = beginContext((pipelineSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$17, {
+        swarm$1.loggerService.log(METHOD_NAME$18, {
             pipelineSchema,
         });
     swarm$1.pipelineValidationService.addPipeline(pipelineSchema.pipelineName, pipelineSchema);
@@ -19074,7 +19631,7 @@ function addPipeline(pipelineSchema) {
  * @private
  * @constant {string}
 */
-const METHOD_NAME$16 = "function.setup.addOutline";
+const METHOD_NAME$17 = "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.
@@ -19082,7 +19639,7 @@ const METHOD_NAME$16 = "function.setup.addOutline";
 */
 const addOutlineInternal = beginContext((outlineSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$16, {
+        swarm$1.loggerService.log(METHOD_NAME$17, {
             outlineSchema,
         });
     swarm$1.outlineValidationService.addOutline(outlineSchema.outlineName, outlineSchema);
@@ -19101,16 +19658,16 @@ function addOutline(outlineSchema) {
     return addOutlineInternal(outlineSchema);
 }
 
-const METHOD_NAME$15 = "function.test.overrideAgent";
+const METHOD_NAME$16 = "function.test.overrideAgent";
 /**
  * Function implementation
 */
 const overrideAgentInternal = beginContext(async (publicAgentSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$15, {
+        swarm$1.loggerService.log(METHOD_NAME$16, {
             agentSchema: publicAgentSchema,
         });
-    await swarm$1.agentValidationService.validate(publicAgentSchema.agentName, METHOD_NAME$15);
+    await swarm$1.agentValidationService.validate(publicAgentSchema.agentName, METHOD_NAME$16);
     const agentSchema = mapAgentSchema(publicAgentSchema);
     return swarm$1.agentSchemaService.override(agentSchema.agentName, agentSchema);
 });
@@ -19137,16 +19694,16 @@ async function overrideAgent(agentSchema) {
     return await overrideAgentInternal(agentSchema);
 }
 
-const METHOD_NAME$14 = "function.test.overrideCompletion";
+const METHOD_NAME$15 = "function.test.overrideCompletion";
 /**
  * Function implementation
  */
 const overrideCompletionInternal = beginContext(async (publicCompletionSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$14, {
+        swarm$1.loggerService.log(METHOD_NAME$15, {
             completionSchema: publicCompletionSchema,
         });
-    await swarm$1.completionValidationService.validate(publicCompletionSchema.completionName, METHOD_NAME$14);
+    await swarm$1.completionValidationService.validate(publicCompletionSchema.completionName, METHOD_NAME$15);
     const completionSchema = mapCompletionSchema(publicCompletionSchema);
     return swarm$1.completionSchemaService.override(completionSchema.completionName, completionSchema);
 });
@@ -19174,16 +19731,16 @@ async function overrideCompletion(completionSchema) {
     return await overrideCompletionInternal(completionSchema);
 }
 
-const METHOD_NAME$13 = "function.test.overrideEmbeding";
+const METHOD_NAME$14 = "function.test.overrideEmbedding";
 /**
  * Function implementation
 */
-const overrideEmbedingInternal = beginContext(async (publicEmbeddingSchema) => {
+const overrideEmbeddingInternal = beginContext(async (publicEmbeddingSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$13, {
+        swarm$1.loggerService.log(METHOD_NAME$14, {
             embeddingSchema: publicEmbeddingSchema,
         });
-    await swarm$1.embeddingValidationService.validate(publicEmbeddingSchema.embeddingName, METHOD_NAME$13);
+    await swarm$1.embeddingValidationService.validate(publicEmbeddingSchema.embeddingName, METHOD_NAME$14);
     const embeddingSchema = removeUndefined(publicEmbeddingSchema);
     return swarm$1.embeddingSchemaService.override(embeddingSchema.embeddingName, embeddingSchema);
 });
@@ -19199,7 +19756,7 @@ const overrideEmbedingInternal = beginContext(async (publicEmbeddingSchema) => {
  *
  * @example
  * // Override an embedding’s schema with new properties
- * overrideEmbeding({
+ * overrideEmbedding({
  *   embeddingName: "TextEmbedding",
  *   persist: true,
  *   callbacks: {
@@ -19208,20 +19765,20 @@ const overrideEmbedingInternal = beginContext(async (publicEmbeddingSchema) => {
  * });
  * // Logs the operation (if enabled) and updates the embedding schema in the swarm.
 */
-async function overrideEmbeding(embeddingSchema) {
-    return await overrideEmbedingInternal(embeddingSchema);
+async function overrideEmbedding(embeddingSchema) {
+    return await overrideEmbeddingInternal(embeddingSchema);
 }
 
-const METHOD_NAME$12 = "function.test.overridePolicy";
+const METHOD_NAME$13 = "function.test.overridePolicy";
 /**
  * Function implementation
 */
 const overridePolicyInternal = beginContext(async (publicPolicySchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$12, {
+        swarm$1.loggerService.log(METHOD_NAME$13, {
             policySchema: publicPolicySchema,
         });
-    await swarm$1.policyValidationService.validate(publicPolicySchema.policyName, METHOD_NAME$12);
+    await swarm$1.policyValidationService.validate(publicPolicySchema.policyName, METHOD_NAME$13);
     const policySchema = removeUndefined(publicPolicySchema);
     return swarm$1.policySchemaService.override(policySchema.policyName, policySchema);
 });
@@ -19248,16 +19805,16 @@ async function overridePolicy(policySchema) {
     return await overridePolicyInternal(policySchema);
 }
 
-const METHOD_NAME$11 = "function.test.overrideState";
+const METHOD_NAME$12 = "function.test.overrideState";
 /**
  * Function implementation
 */
 const overrideStateInternal = beginContext(async (publicStateSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$11, {
+        swarm$1.loggerService.log(METHOD_NAME$12, {
             stateSchema: publicStateSchema,
         });
-    await swarm$1.stateValidationService.validate(publicStateSchema.stateName, METHOD_NAME$11);
+    await swarm$1.stateValidationService.validate(publicStateSchema.stateName, METHOD_NAME$12);
     const stateSchema = removeUndefined(publicStateSchema);
     return swarm$1.stateSchemaService.override(stateSchema.stateName, stateSchema);
 });
@@ -19285,16 +19842,16 @@ async function overrideState(stateSchema) {
     return await overrideStateInternal(stateSchema);
 }
 
-const METHOD_NAME$10 = "function.test.overrideStorage";
+const METHOD_NAME$11 = "function.test.overrideStorage";
 /**
  * Function implementation
 */
 const overrideStorageInternal = beginContext(async (publicStorageSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$10, {
+        swarm$1.loggerService.log(METHOD_NAME$11, {
             storageSchema: publicStorageSchema,
         });
-    await swarm$1.storageValidationService.validate(publicStorageSchema.storageName, METHOD_NAME$10);
+    await swarm$1.storageValidationService.validate(publicStorageSchema.storageName, METHOD_NAME$11);
     const storageSchema = removeUndefined(publicStorageSchema);
     return swarm$1.storageSchemaService.override(storageSchema.storageName, storageSchema);
 });
@@ -19323,16 +19880,16 @@ async function overrideStorage(storageSchema) {
     return await overrideStorageInternal(storageSchema);
 }
 
-const METHOD_NAME$$ = "function.test.overrideSwarm";
+const METHOD_NAME$10 = "function.test.overrideSwarm";
 /**
  * Function implementation
 */
 const overrideSwarmInternal = beginContext(async (publicSwarmSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$$, {
+        swarm$1.loggerService.log(METHOD_NAME$10, {
             swarmSchema: publicSwarmSchema,
         });
-    await swarm$1.swarmValidationService.validate(publicSwarmSchema.swarmName, METHOD_NAME$$);
+    await swarm$1.swarmValidationService.validate(publicSwarmSchema.swarmName, METHOD_NAME$10);
     const swarmSchema = removeUndefined(publicSwarmSchema);
     return swarm$1.swarmSchemaService.override(swarmSchema.swarmName, swarmSchema);
 });
@@ -19359,16 +19916,16 @@ async function overrideSwarm(swarmSchema) {
     return await overrideSwarmInternal(swarmSchema);
 }
 
-const METHOD_NAME$_ = "function.test.overrideTool";
+const METHOD_NAME$$ = "function.test.overrideTool";
 /**
  * Function implementation
 */
 const overrideToolInternal = beginContext(async (publicToolSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$_, {
+        swarm$1.loggerService.log(METHOD_NAME$$, {
             toolSchema: publicToolSchema,
         });
-    await swarm$1.toolValidationService.validate(publicToolSchema.toolName, METHOD_NAME$_);
+    await swarm$1.toolValidationService.validate(publicToolSchema.toolName, METHOD_NAME$$);
     const toolSchema = removeUndefined(publicToolSchema);
     return swarm$1.toolSchemaService.override(toolSchema.toolName, toolSchema);
 });
@@ -19394,16 +19951,16 @@ async function overrideTool(toolSchema) {
     return await overrideToolInternal(toolSchema);
 }
 
-const METHOD_NAME$Z = "function.test.overrideMCP";
+const METHOD_NAME$_ = "function.test.overrideMCP";
 /**
  * Function implementation
 */
 const overrideMCPInternal = beginContext(async (publicMcpSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$Z, {
+        swarm$1.loggerService.log(METHOD_NAME$_, {
             mcpSchema: publicMcpSchema,
         });
-    await swarm$1.mcpValidationService.validate(publicMcpSchema.mcpName, METHOD_NAME$Z);
+    await swarm$1.mcpValidationService.validate(publicMcpSchema.mcpName, METHOD_NAME$_);
     const mcpSchema = removeUndefined(publicMcpSchema);
     return swarm$1.mcpSchemaService.override(mcpSchema.mcpName, mcpSchema);
 });
@@ -19415,16 +19972,16 @@ async function overrideMCP(mcpSchema) {
     return await overrideMCPInternal(mcpSchema);
 }
 
-const METHOD_NAME$Y = "function.test.overrideAdvisor";
+const METHOD_NAME$Z = "function.test.overrideAdvisor";
 /**
  * Function implementation
  */
 const overrideAdvisorInternal = beginContext(async (publicAdvisorSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$Y, {
+        swarm$1.loggerService.log(METHOD_NAME$Z, {
             advisorSchema: publicAdvisorSchema,
         });
-    await swarm$1.advisorValidationService.validate(publicAdvisorSchema.advisorName, METHOD_NAME$Y);
+    await swarm$1.advisorValidationService.validate(publicAdvisorSchema.advisorName, METHOD_NAME$Z);
     const advisorSchema = removeUndefined(publicAdvisorSchema);
     return swarm$1.advisorSchemaService.override(advisorSchema.advisorName, advisorSchema);
 });
@@ -19469,16 +20026,16 @@ async function overrideAdvisor(advisorSchema) {
  * Method name for the overrideCompute operation.
  * @private
 */
-const METHOD_NAME$X = "function.test.overrideCompute";
+const METHOD_NAME$Y = "function.test.overrideCompute";
 /**
  * Function implementation
 */
 const overrideComputeInternal = beginContext(async (publicComputeSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$X, {
+        swarm$1.loggerService.log(METHOD_NAME$Y, {
             computeSchema: publicComputeSchema,
         });
-    await swarm$1.computeValidationService.validate(publicComputeSchema.computeName, METHOD_NAME$X);
+    await swarm$1.computeValidationService.validate(publicComputeSchema.computeName, METHOD_NAME$Y);
     const computeSchema = removeUndefined(publicComputeSchema);
     return swarm$1.computeSchemaService.override(computeSchema.computeName, computeSchema);
 });
@@ -19500,16 +20057,16 @@ async function overrideCompute(computeSchema) {
  * Method name for the overridePipeline operation.
  * @private
 */
-const METHOD_NAME$W = "function.test.overridePipeline";
+const METHOD_NAME$X = "function.test.overridePipeline";
 /**
  * Function implementation
 */
 const overridePipelineInternal = beginContext(async (publicPipelineSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$W, {
+        swarm$1.loggerService.log(METHOD_NAME$X, {
             pipelineSchema: publicPipelineSchema,
         });
-    await swarm$1.pipelineValidationService.validate(publicPipelineSchema.pipelineName, METHOD_NAME$W);
+    await swarm$1.pipelineValidationService.validate(publicPipelineSchema.pipelineName, METHOD_NAME$X);
     const pipelineSchema = removeUndefined(publicPipelineSchema);
     return swarm$1.pipelineSchemaService.override(pipelineSchema.pipelineName, pipelineSchema);
 });
@@ -19529,7 +20086,7 @@ async function overridePipeline(pipelineSchema) {
  * @private
  * @constant {string}
 */
-const METHOD_NAME$V = "function.test.overrideOutline";
+const METHOD_NAME$W = "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.
@@ -19537,10 +20094,10 @@ const METHOD_NAME$V = "function.test.overrideOutline";
 */
 const overrideOutlineInternal = beginContext(async (publicOutlineSchema) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$V, {
+        swarm$1.loggerService.log(METHOD_NAME$W, {
             outlineSchema: publicOutlineSchema,
         });
-    await swarm$1.outlineValidationService.validate(publicOutlineSchema.outlineName, METHOD_NAME$V);
+    await swarm$1.outlineValidationService.validate(publicOutlineSchema.outlineName, METHOD_NAME$W);
     const outlineSchema = removeUndefined(publicOutlineSchema);
     return swarm$1.outlineSchemaService.override(outlineSchema.outlineName, outlineSchema);
 });
@@ -19556,23 +20113,23 @@ async function overrideOutline(outlineSchema) {
     return await overrideOutlineInternal(outlineSchema);
 }
 
-const METHOD_NAME$U = "function.other.markOnline";
+const METHOD_NAME$V = "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$U, {
+        swarm.loggerService.log(METHOD_NAME$V, {
             clientId,
         });
     // Validate the swarm name
-    swarm.swarmValidationService.validate(swarmName, METHOD_NAME$U);
+    swarm.swarmValidationService.validate(swarmName, METHOD_NAME$V);
     // Run the operation in the method context
     return await MethodContextService.runInContext(async () => {
-        await swarm.aliveService.markOnline(clientId, swarmName, METHOD_NAME$U);
+        await swarm.aliveService.markOnline(clientId, swarmName, METHOD_NAME$V);
     }, {
-        methodName: METHOD_NAME$U,
+        methodName: METHOD_NAME$V,
         agentName: "",
         policyName: "",
         stateName: "",
@@ -19595,20 +20152,20 @@ async function markOnline(clientId, swarmName) {
     return await markOnlineInternal(clientId, swarmName);
 }
 
-const METHOD_NAME$T = "function.other.markOffline";
+const METHOD_NAME$U = "function.other.markOffline";
 /**
  * Function implementation
 */
 const markOfflineInternal = async (clientId, swarmName) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm.loggerService.log(METHOD_NAME$T, {
+        swarm.loggerService.log(METHOD_NAME$U, {
             clientId,
         });
-    swarm.swarmValidationService.validate(swarmName, METHOD_NAME$T);
+    swarm.swarmValidationService.validate(swarmName, METHOD_NAME$U);
     return await MethodContextService.runInContext(async () => {
-        await swarm.aliveService.markOffline(clientId, swarmName, METHOD_NAME$T);
+        await swarm.aliveService.markOffline(clientId, swarmName, METHOD_NAME$U);
     }, {
-        methodName: METHOD_NAME$T,
+        methodName: METHOD_NAME$U,
         agentName: "",
         policyName: "",
         stateName: "",
@@ -19636,27 +20193,27 @@ async function markOffline(clientId, swarmName) {
 }
 
 /** @private Constant defining the method name for logging and validation context*/
-const METHOD_NAME$S = "function.commit.commitSystemMessage";
+const METHOD_NAME$T = "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$S, {
+        swarm$1.loggerService.log(METHOD_NAME$T, {
             content,
             clientId,
             agentName,
         });
     // Validate the agent exists
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$S);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$T);
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$S);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$T);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$S);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$T);
     // Check if the current agent matches the provided agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$S, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$T, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "commitSystemMessage" skipped due to the agent change', {
@@ -19667,7 +20224,7 @@ const commitSystemMessageInternal = beginContext(async (content, clientId, agent
         return;
     }
     // Commit the system message via SessionPublicService
-    await swarm$1.sessionPublicService.commitSystemMessage(content, METHOD_NAME$S, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitSystemMessage(content, METHOD_NAME$T, clientId, swarmName);
 });
 /**
  * Commits a system-generated message to the active agent in the swarm system.
@@ -19689,22 +20246,22 @@ async function commitSystemMessage(content, clientId, agentName) {
 }
 
 /** @private Constant defining the method name for logging and validation context*/
-const METHOD_NAME$R = "function.commit.commitDeveloperMessage";
+const METHOD_NAME$S = "function.commit.commitDeveloperMessage";
 /**
  * Function implementation
 */
 const commitDeveloperMessageInternal = beginContext(async (content, clientId, agentName) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$R, {
+        swarm$1.loggerService.log(METHOD_NAME$S, {
             content,
             clientId,
             agentName,
         });
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$R);
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$R);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$S);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$S);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$R);
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$R, clientId, swarmName);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$S);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$S, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "commitDeveloperMessage" skipped due to the agent change', {
@@ -19714,7 +20271,7 @@ const commitDeveloperMessageInternal = beginContext(async (content, clientId, ag
             });
         return;
     }
-    await swarm$1.sessionPublicService.commitDeveloperMessage(content, METHOD_NAME$R, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitDeveloperMessage(content, METHOD_NAME$S, clientId, swarmName);
 });
 /**
  * Commits a developer-generated message to the active agent in the swarm system.
@@ -19735,26 +20292,26 @@ async function commitDeveloperMessage(content, clientId, agentName) {
     return await commitDeveloperMessageInternal(content, clientId, agentName);
 }
 
-const METHOD_NAME$Q = "function.commit.commitSystemMessage";
+const METHOD_NAME$R = "function.commit.commitUserMessage";
 /**
  * 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$Q, {
+        swarm$1.loggerService.log(METHOD_NAME$R, {
             content,
             clientId,
             agentName,
             mode,
         });
     // Validate the agent, session, and swarm to ensure they exist and are accessible
-    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);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$R);
     // Check if the specified agent is still the active agent in the swarm session
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$Q, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$R, clientId, swarmName);
     if (currentAgentName !== agentName) {
         // Log a skip message if the agent has changed during the operation
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
@@ -19767,14 +20324,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$Q, clientId, swarmName);
+            await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$R, 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$Q, clientId, swarmName);
+    return await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$R, clientId, swarmName);
 });
 /**
  * Commits a user message to the active agent's history in a swarm session without triggering a response.
@@ -19798,24 +20355,24 @@ async function commitUserMessage(content, mode, clientId, agentName, payload) {
 }
 
 /** @private Constant defining the method name for logging and validation context*/
-const METHOD_NAME$P = "function.commit.commitSystemMessageForce";
+const METHOD_NAME$Q = "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$P, {
+        swarm$1.loggerService.log(METHOD_NAME$Q, {
             content,
             clientId,
         });
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$P);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$Q);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$P);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$Q);
     // Commit the system message via SessionPublicService without agent checks
-    await swarm$1.sessionPublicService.commitSystemMessage(content, METHOD_NAME$P, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitSystemMessage(content, METHOD_NAME$Q, clientId, swarmName);
 });
 /**
  * Forcefully commits a system-generated message to a session in the swarm system, without checking the active agent.
@@ -19836,7 +20393,7 @@ async function commitSystemMessageForce(content, clientId) {
 }
 
 /** @private Constant defining the method name for logging and validation context*/
-const METHOD_NAME$O = "function.commit.commitDeveloperMessageForce";
+const METHOD_NAME$P = "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.
@@ -19849,14 +20406,14 @@ const METHOD_NAME$O = "function.commit.commitDeveloperMessageForce";
 */
 const commitDeveloperMessageForceInternal = beginContext(async (content, clientId) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$O, {
+        swarm$1.loggerService.log(METHOD_NAME$P, {
             content,
             clientId,
         });
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$O);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$P);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$O);
-    await swarm$1.sessionPublicService.commitDeveloperMessage(content, METHOD_NAME$O, clientId, swarmName);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$P);
+    await swarm$1.sessionPublicService.commitDeveloperMessage(content, METHOD_NAME$P, clientId, swarmName);
 });
 /**
  * Forcefully commits a developer-generated message to a session in the swarm system, without checking the active agent.
@@ -19875,32 +20432,32 @@ async function commitDeveloperMessageForce(content, clientId) {
     return await commitDeveloperMessageForceInternal(content, clientId);
 }
 
-const METHOD_NAME$N = "function.commit.commitSystemMessage";
+const METHOD_NAME$O = "function.commit.commitUserMessageForce";
 /**
  * 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$N, {
+        swarm$1.loggerService.log(METHOD_NAME$O, {
             content,
             clientId,
             mode,
         });
     // Validate the session and swarm to ensure they exist and are accessible
-    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);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$O);
     if (payload) {
         return await PayloadContextService.runInContext(async () => {
-            await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$N, clientId, swarmName);
+            await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$O, 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$N, clientId, swarmName);
+    return await swarm$1.sessionPublicService.commitUserMessage(content, mode, METHOD_NAME$O, 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.
@@ -19923,27 +20480,27 @@ async function commitUserMessageForce(content, mode, clientId, payload) {
 }
 
 /** @private Constant defining the method name for logging and validation context*/
-const METHOD_NAME$M = "function.commit.commitAssistantMessage";
+const METHOD_NAME$N = "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$M, {
+        swarm$1.loggerService.log(METHOD_NAME$N, {
             content,
             clientId,
             agentName,
         });
     // Validate the agent exists
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$M);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$N);
     // Validate the session exists and retrieve the associated swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$M);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$N);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
     // Validate the swarm configuration
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$M);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$N);
     // Check if the current agent matches the provided agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$M, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$N, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "commitAssistantMessage" skipped due to the agent change', {
@@ -19954,7 +20511,7 @@ const commitAssistantMessageInternal = beginContext(async (content, clientId, ag
         return;
     }
     // Commit the assistant message via SessionPublicService
-    await swarm$1.sessionPublicService.commitAssistantMessage(content, METHOD_NAME$M, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitAssistantMessage(content, METHOD_NAME$N, clientId, swarmName);
 });
 /**
  * Commits an assistant-generated message to the active agent in the swarm system.
@@ -19975,24 +20532,24 @@ async function commitAssistantMessage(content, clientId, agentName) {
 }
 
 /** @private Constant defining the method name for logging and validation context*/
-const METHOD_NAME$L = "function.commit.commitAssistantMessageForce";
+const METHOD_NAME$M = "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$L, {
+        swarm$1.loggerService.log(METHOD_NAME$M, {
             content,
             clientId,
         });
     // 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);
     // Commit the assistant message via SessionPublicService without agent checks
-    await swarm$1.sessionPublicService.commitAssistantMessage(content, METHOD_NAME$L, clientId, swarmName);
+    await swarm$1.sessionPublicService.commitAssistantMessage(content, METHOD_NAME$M, clientId, swarmName);
 });
 /**
  * Forcefully commits an assistant-generated message to a session in the swarm system, without checking the active agent.
@@ -20013,26 +20570,26 @@ async function commitAssistantMessageForce(content, clientId) {
 }
 
 /** @private Constant defining the method name for logging and validation context*/
-const METHOD_NAME$K = "function.commit.cancelOutput";
+const METHOD_NAME$L = "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$K, {
+        swarm$1.loggerService.log(METHOD_NAME$L, {
             clientId,
             agentName,
         });
     // Validate the agent exists
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$K);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$L);
     // 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);
     // Check if the current agent matches the provided agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$K, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$L, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "cancelOutput" skipped due to the agent change', {
@@ -20043,7 +20600,7 @@ const cancelOutputInternal = beginContext(async (clientId, agentName) => {
         return;
     }
     // Perform the output cancellation via SwarmPublicService
-    await swarm$1.swarmPublicService.cancelOutput(METHOD_NAME$K, clientId, swarmName);
+    await swarm$1.swarmPublicService.cancelOutput(METHOD_NAME$L, clientId, swarmName);
 });
 /**
  * Cancels the awaited output for a specific client and agent by emitting an empty string.
@@ -20062,23 +20619,23 @@ async function cancelOutput(clientId, agentName) {
 }
 
 /** @private Constant defining the method name for logging and validation context*/
-const METHOD_NAME$J = "function.commit.cancelOutputForce";
+const METHOD_NAME$K = "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$J, {
+        swarm$1.loggerService.log(METHOD_NAME$K, {
             clientId,
         });
     // 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);
     // Perform the output cancellation via SwarmPublicService without agent checks
-    await swarm$1.swarmPublicService.cancelOutput(METHOD_NAME$J, clientId, swarmName);
+    await swarm$1.swarmPublicService.cancelOutput(METHOD_NAME$K, clientId, swarmName);
 });
 /**
  * Forcefully cancels the awaited output for a specific client by emitting an empty string, without checking the active agent.
@@ -20096,22 +20653,22 @@ async function cancelOutputForce(clientId) {
     return await cancelOutputForceInternal(clientId);
 }
 
-const METHOD_NAME$I = "function.commit.commitToolRequest";
+const METHOD_NAME$J = "function.commit.commitToolRequest";
 /**
  * Function implementation
 */
 const commitToolRequestInternal = beginContext(async (request, clientId, agentName) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$I, {
+        swarm$1.loggerService.log(METHOD_NAME$J, {
             request,
             clientId,
             agentName,
         });
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$I);
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$I);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$J);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$J);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$I);
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$I, clientId, swarmName);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$J);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$J, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "commitToolRequest" skipped due to the agent change', {
@@ -20121,7 +20678,7 @@ const commitToolRequestInternal = beginContext(async (request, clientId, agentNa
             });
         return null;
     }
-    return await swarm$1.sessionPublicService.commitToolRequest(Array.isArray(request) ? request : [request], METHOD_NAME$I, clientId, swarmName);
+    return await swarm$1.sessionPublicService.commitToolRequest(Array.isArray(request) ? request : [request], METHOD_NAME$J, clientId, swarmName);
 });
 /**
  * Commits a tool request to the active agent in the swarm system.
@@ -20136,21 +20693,21 @@ async function commitToolRequest(request, clientId, agentName) {
     return await commitToolRequestInternal(request, clientId, agentName);
 }
 
-const METHOD_NAME$H = "function.commit.commitToolRequestForce";
+const METHOD_NAME$I = "function.commit.commitToolRequestForce";
 /**
  * Function implementation
 */
 const commitToolRequestForceInternal = beginContext(async (request, clientId) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$H, {
+        swarm$1.loggerService.log(METHOD_NAME$I, {
             request,
             clientId,
         });
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$H);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$I);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$H);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$I);
     const requests = Array.isArray(request) ? request : [request];
-    return await swarm$1.sessionPublicService.commitToolRequest(requests, METHOD_NAME$H, clientId, swarmName);
+    return await swarm$1.sessionPublicService.commitToolRequest(requests, METHOD_NAME$I, clientId, swarmName);
 });
 /**
  * Forcefully commits a tool request to the active agent in the swarm system.
@@ -20167,18 +20724,18 @@ async function commitToolRequestForce(request, clientId) {
 }
 
 /** @constant {string} METHOD_NAME - The name of the method used for logging and validation*/
-const METHOD_NAME$G = "function.target.ask";
+const METHOD_NAME$H = "function.target.ask";
 /**
  * Function implementation
 */
 const askInternal = beginContext(async (message, advisorName) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$G, {
+        swarm$1.loggerService.log(METHOD_NAME$H, {
             message,
             advisorName,
         });
     const resultId = randomString();
-    swarm$1.advisorValidationService.validate(advisorName, METHOD_NAME$G);
+    swarm$1.advisorValidationService.validate(advisorName, METHOD_NAME$H);
     const { getChat, callbacks } = swarm$1.advisorSchemaService.get(advisorName);
     if (callbacks?.onChat) {
         callbacks.onChat(message);
@@ -20221,7 +20778,7 @@ async function ask(message, advisorName) {
     return await askInternal(message, advisorName);
 }
 
-const METHOD_NAME$F = "function.target.json";
+const METHOD_NAME$G = "function.target.json";
 const MAX_ATTEMPTS = 5;
 /**
  * A class implementing the IOutlineHistory interface to manage a history of outline messages.
@@ -20265,12 +20822,12 @@ class OutlineHistory {
  */
 const jsonInternal = beginContext(async (outlineName, ...params) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$F, {});
-    swarm$1.outlineValidationService.validate(outlineName, METHOD_NAME$F);
+        swarm$1.loggerService.log(METHOD_NAME$G, {});
+    swarm$1.outlineValidationService.validate(outlineName, METHOD_NAME$G);
     const resultId = 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$F);
+    swarm$1.completionValidationService.validate(completion, METHOD_NAME$G);
     const completionSchema = swarm$1.completionSchemaService.get(completion);
     const { getCompletion, flags = [], callbacks: completionCallbacks, } = completionSchema;
     let errorMessage = "";
@@ -20403,7 +20960,7 @@ async function json(outlineName, ...params) {
     return await jsonInternal(outlineName, ...params);
 }
 
-const METHOD_NAME$E = "function.target.chat";
+const METHOD_NAME$F = "function.target.chat";
 /**
  * Internal function to process a chat completion request.
  * Executes outside existing contexts using `beginContext` to ensure isolation.
@@ -20413,13 +20970,13 @@ const METHOD_NAME$E = "function.target.chat";
  */
 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);
+        swarm$1.loggerService.log(METHOD_NAME$F, {});
+    swarm$1.completionValidationService.validate(completionName, METHOD_NAME$F);
     const resultId = 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.`);
+        throw new Error(`${METHOD_NAME$F} completion ${completionName} should not have json=true. Use a non-JSON completion for chat.`);
     }
     const { getCompletion } = completionSchema;
     let errorValue = null;
@@ -20459,7 +21016,7 @@ async function chat(completionName, messages) {
     return await chatInternal(completionName, messages);
 }
 
-const METHOD_NAME$D = "function.target.disposeConnection";
+const METHOD_NAME$E = "function.target.disposeConnection";
 /**
  * Disposes of a client session and all related resources within a swarm.
  *
@@ -20472,10 +21029,10 @@ const METHOD_NAME$D = "function.target.disposeConnection";
  * @example
  * await disposeConnection("client-123", "TaskSwarm");
 */
-const disposeConnection = beginContext(async (clientId, swarmName, methodName = METHOD_NAME$D) => {
+const disposeConnection = beginContext(async (clientId, swarmName, methodName = METHOD_NAME$E) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$D, {
+        swarm$1.loggerService.log(METHOD_NAME$E, {
             clientId,
             swarmName,
         });
@@ -20581,7 +21138,7 @@ const disposeConnection = beginContext(async (clientId, swarmName, methodName =
     PersistMemoryAdapter.dispose(clientId);
 });
 
-const METHOD_NAME$C = "function.target.makeAutoDispose";
+const METHOD_NAME$D = "function.target.makeAutoDispose";
 /**
  * Default timeout in seconds before auto-dispose is triggered.
  * @constant {number}
@@ -20608,7 +21165,7 @@ const DEFAULT_TIMEOUT = 15 * 60;
 const makeAutoDispose = beginContext((clientId, swarmName, { timeoutSeconds = DEFAULT_TIMEOUT, onDestroy, } = {}) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$C, {
+        swarm$1.loggerService.log(METHOD_NAME$D, {
             clientId,
             swarmName,
         });
@@ -20641,30 +21198,30 @@ const makeAutoDispose = beginContext((clientId, swarmName, { timeoutSeconds = DE
     };
 });
 
-const METHOD_NAME$B = "function.target.notify";
+const METHOD_NAME$C = "function.target.notify";
 /**
  * Function implementation
 */
 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$B, {
+        swarm$1.loggerService.log(METHOD_NAME$C, {
             content,
             clientId,
             agentName,
         });
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$B);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$C);
     // Check if the session mode is "makeConnection"
     if (swarm$1.sessionValidationService.getSessionMode(clientId) !==
         "makeConnection") {
         throw new Error(`agent-swarm-kit notify session is not makeConnection clientId=${clientId}`);
     }
     // Validate the agent, session, and swarm
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$B);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$C);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$B);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$C);
     // Check if the specified agent is still the active agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$B, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$C, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "notify" skipped due to the agent change', {
@@ -20675,7 +21232,7 @@ const notifyInternal = beginContext(async (content, clientId, agentName) => {
         return;
     }
     // Notify the content directly via the session public service
-    return await swarm$1.sessionPublicService.notify(content, METHOD_NAME$B, clientId, swarmName);
+    return await swarm$1.sessionPublicService.notify(content, METHOD_NAME$C, clientId, swarmName);
 });
 /**
  * Sends a notification message as output from the swarm session without executing an incoming message.
@@ -20697,18 +21254,18 @@ async function notify(content, clientId, agentName) {
     return await notifyInternal(content, clientId, agentName);
 }
 
-const METHOD_NAME$A = "function.target.notifyForce";
+const METHOD_NAME$B = "function.target.notifyForce";
 /**
  * Function implementation
 */
 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$A, {
+        swarm$1.loggerService.log(METHOD_NAME$B, {
             content,
             clientId,
         });
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$A);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$B);
     // Check if the session mode is "makeConnection"
     if (swarm$1.sessionValidationService.getSessionMode(clientId) !==
         "makeConnection") {
@@ -20716,9 +21273,9 @@ const notifyForceInternal = beginContext(async (content, clientId) => {
     }
     // Validate the agent, session, and swarm
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$A);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$B);
     // Notify the content directly via the session public service
-    return await swarm$1.sessionPublicService.notify(content, METHOD_NAME$A, clientId, swarmName);
+    return await swarm$1.sessionPublicService.notify(content, METHOD_NAME$B, clientId, swarmName);
 });
 /**
  * Sends a notification message as output from the swarm session without executing an incoming message.
@@ -20739,7 +21296,7 @@ async function notifyForce(content, clientId) {
     return await notifyForceInternal(content, clientId);
 }
 
-const METHOD_NAME$z = "function.target.runStateless";
+const METHOD_NAME$A = "function.target.runStateless";
 /**
  * Function implementation
 */
@@ -20747,19 +21304,19 @@ const runStatelessInternal = beginContext(async (content, clientId, agentName) =
     const executionId = randomString();
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$z, {
+        swarm$1.loggerService.log(METHOD_NAME$A, {
             content,
             clientId,
             agentName,
             executionId,
         });
     // Validate the agent, session, and swarm
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$z);
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$z);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$A);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$A);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$z);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$A);
     // Check if the specified agent is still the active agent
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$z, clientId, swarmName);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$A, clientId, swarmName);
     if (currentAgentName !== agentName) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log('function "runStateless" skipped due to the agent change', {
@@ -20785,7 +21342,7 @@ const runStatelessInternal = beginContext(async (content, clientId, agentName) =
                     errorValue = error;
                 }
             });
-            result = await swarm$1.sessionPublicService.run(content, METHOD_NAME$z, clientId, swarmName);
+            result = await swarm$1.sessionPublicService.run(content, METHOD_NAME$A, clientId, swarmName);
             unError();
             if (errorValue) {
                 throw errorValue;
@@ -20831,7 +21388,7 @@ async function runStateless(content, clientId, agentName) {
     return await runStatelessInternal(content, clientId, agentName);
 }
 
-const METHOD_NAME$y = "function.target.runStatelessForce";
+const METHOD_NAME$z = "function.target.runStatelessForce";
 /**
  * Function implementation
 */
@@ -20839,15 +21396,15 @@ const runStatelessForceInternal = beginContext(async (content, clientId) => {
     const executionId = randomString();
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$y, {
+        swarm$1.loggerService.log(METHOD_NAME$z, {
             content,
             clientId,
             executionId,
         });
     // Validate the session and swarm
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$y);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$z);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$y);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$z);
     // Execute the command statelessly within an execution context with performance tracking
     return ExecutionContextService.runInContext(async () => {
         let isFinished = false;
@@ -20861,7 +21418,7 @@ const runStatelessForceInternal = beginContext(async (content, clientId) => {
                     errorValue = error;
                 }
             });
-            result = await swarm$1.sessionPublicService.run(content, METHOD_NAME$y, clientId, swarmName);
+            result = await swarm$1.sessionPublicService.run(content, METHOD_NAME$z, clientId, swarmName);
             unError();
             if (errorValue) {
                 throw errorValue;
@@ -20912,7 +21469,7 @@ const SCHEDULED_DELAY$1 = 1000;
  * @constant {number}
 */
 const RATE_DELAY = 10000;
-const METHOD_NAME$x = "function.target.makeConnection";
+const METHOD_NAME$y = "function.target.makeConnection";
 /**
  * Internal implementation of the connection factory for a client to a swarm.
  *
@@ -20923,21 +21480,21 @@ const METHOD_NAME$x = "function.target.makeConnection";
 const makeConnectionInternal = (connector, clientId, swarmName) => {
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$x, {
+        swarm$1.loggerService.log(METHOD_NAME$y, {
             clientId,
             swarmName,
         });
     // Validate the swarm and initialize the session
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$x);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$y);
     swarm$1.sessionValidationService.addSession(clientId, swarmName, "makeConnection");
     // Create a queued send function using the session public service
-    const send = queued(swarm$1.sessionPublicService.connect(connector, METHOD_NAME$x, clientId, swarmName));
+    const send = queued(swarm$1.sessionPublicService.connect(connector, METHOD_NAME$y, clientId, swarmName));
     // Return a wrapped send function with validation and agent context
     return (async (outgoing) => {
-        swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$x);
+        swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$y);
         return await send({
             data: outgoing,
-            agentName: await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$x, clientId, swarmName),
+            agentName: await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$y, clientId, swarmName),
             clientId,
         });
     });
@@ -21011,13 +21568,13 @@ makeConnection.scheduled = (connector, clientId, swarmName, { delay = SCHEDULED_
             await online();
             if (payload) {
                 return await PayloadContextService.runInContext(async () => {
-                    await swarm$1.sessionPublicService.commitUserMessage(content, "user", METHOD_NAME$x, clientId, swarmName);
+                    await swarm$1.sessionPublicService.commitUserMessage(content, "user", METHOD_NAME$y, clientId, swarmName);
                 }, {
                     clientId,
                     payload,
                 });
             }
-            await swarm$1.sessionPublicService.commitUserMessage(content, "user", METHOD_NAME$x, clientId, swarmName);
+            await swarm$1.sessionPublicService.commitUserMessage(content, "user", METHOD_NAME$y, clientId, swarmName);
         }),
         delay,
     });
@@ -21075,7 +21632,7 @@ makeConnection.rate = (connector, clientId, swarmName, { delay = RATE_DELAY } =
     };
 };
 
-const METHOD_NAME$w = "function.target.complete";
+const METHOD_NAME$x = "function.target.complete";
 /**
  * Creates a complete function with time-to-live (TTL) and queuing capabilities.
  *
@@ -21120,7 +21677,7 @@ const complete = beginContext(async (content, clientId, swarmName, payload = nul
     const executionId = randomString();
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$w, {
+        swarm$1.loggerService.log(METHOD_NAME$x, {
             content,
             clientId,
             executionId,
@@ -21138,7 +21695,7 @@ const complete = beginContext(async (content, clientId, swarmName, payload = nul
             swarm$1.navigationValidationService.beginMonit(clientId, swarmName);
             try {
                 swarm$1.busService.commitExecutionBegin(clientId, { swarmName });
-                const result = await run(METHOD_NAME$w, content);
+                const result = await run(METHOD_NAME$x, content);
                 isFinished = swarm$1.perfService.endExecution(executionId, clientId, result.length);
                 swarm$1.busService.commitExecutionEnd(clientId, { swarmName });
                 return result;
@@ -21169,7 +21726,7 @@ const complete = beginContext(async (content, clientId, swarmName, payload = nul
  * @constant {number}
 */
 const SCHEDULED_DELAY = 1000;
-const METHOD_NAME$v = "function.target.session";
+const METHOD_NAME$w = "function.target.session";
 /**
  * Internal implementation of the session factory for a client and swarm.
  *
@@ -21181,23 +21738,33 @@ const sessionInternal = (clientId, swarmName, { onDispose = () => { } } = {}) =>
     const executionId = randomString();
     // Log the operation details if logging is enabled in GLOBAL_CONFIG
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$v, {
+        swarm$1.loggerService.log(METHOD_NAME$w, {
             clientId,
             swarmName,
             executionId,
         });
     // Validate the swarm and initialize the session
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$v);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$w);
     swarm$1.sessionValidationService.addSession(clientId, swarmName, "session");
     const complete = queued(async (content) => {
-        swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$v);
+        swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$w);
         return ExecutionContextService.runInContext(async () => {
             let isFinished = false;
             swarm$1.perfService.startExecution(executionId, clientId, content.length);
             swarm$1.navigationValidationService.beginMonit(clientId, swarmName);
             try {
                 swarm$1.busService.commitExecutionBegin(clientId, { swarmName });
-                const result = await swarm$1.sessionPublicService.execute(content, "user", METHOD_NAME$v, clientId, swarmName);
+                let errorValue = null;
+                const unError = errorSubject.subscribe(([errorClientId, error]) => {
+                    if (clientId === errorClientId) {
+                        errorValue = error;
+                    }
+                });
+                const result = await swarm$1.sessionPublicService.execute(content, "user", METHOD_NAME$w, clientId, swarmName);
+                unError();
+                if (errorValue) {
+                    throw errorValue;
+                }
                 isFinished = swarm$1.perfService.endExecution(executionId, clientId, result.length);
                 swarm$1.busService.commitExecutionEnd(clientId, { swarmName });
                 return result;
@@ -21219,7 +21786,7 @@ const sessionInternal = (clientId, swarmName, { onDispose = () => { } } = {}) =>
             return await complete(content);
         }),
         dispose: async () => {
-            await disposeConnection(clientId, swarmName, METHOD_NAME$v);
+            await disposeConnection(clientId, swarmName, METHOD_NAME$w);
             await onDispose();
         },
     };
@@ -21312,13 +21879,13 @@ session.scheduled = (clientId, swarmName, { delay = SCHEDULED_DELAY, onDispose }
             await online();
             if (payload) {
                 return await PayloadContextService.runInContext(async () => {
-                    return await swarm$1.sessionPublicService.commitUserMessage(content, "user", METHOD_NAME$v, clientId, swarmName);
+                    return await swarm$1.sessionPublicService.commitUserMessage(content, "user", METHOD_NAME$w, clientId, swarmName);
                 }, {
                     clientId,
                     payload,
                 });
             }
-            return await swarm$1.sessionPublicService.commitUserMessage(content, "user", METHOD_NAME$v, clientId, swarmName);
+            return await swarm$1.sessionPublicService.commitUserMessage(content, "user", METHOD_NAME$w, clientId, swarmName);
         }),
         delay,
     });
@@ -21402,13 +21969,13 @@ session.rate = (clientId, swarmName, { delay = SCHEDULED_DELAY, onDispose } = {}
  * Method name for the scope operation.
  * @private
 */
-const METHOD_NAME$u = "function.target.fork";
+const METHOD_NAME$v = "function.target.fork";
 /**
  * Function implementation
 */
 const forkInternal = beginContext(async (runFn, { clientId, swarmName, onError }) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$u, {
+        swarm$1.loggerService.log(METHOD_NAME$v, {
             clientId,
             swarmName,
         });
@@ -21416,9 +21983,9 @@ const forkInternal = beginContext(async (runFn, { clientId, swarmName, onError }
         throw new Error(`agent-swarm scope Session already exists for clientId=${clientId}`);
     }
     swarm$1.sessionValidationService.addSession(clientId, swarmName, "scope");
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$u);
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$u);
-    const agentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$u, clientId, swarmName);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$v);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$v);
+    const agentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$v, clientId, swarmName);
     let result = null;
     try {
         result = (await runFn(clientId, agentName));
@@ -21428,7 +21995,7 @@ const forkInternal = beginContext(async (runFn, { clientId, swarmName, onError }
         onError && onError(error);
     }
     finally {
-        await disposeConnection(clientId, swarmName, METHOD_NAME$u);
+        await disposeConnection(clientId, swarmName, METHOD_NAME$v);
     }
     return result;
 });
@@ -21453,12 +22020,12 @@ async function fork(runFn, options) {
  * Method name for the scope operation.
  * @private
 */
-const METHOD_NAME$t = "function.target.scope";
+const METHOD_NAME$u = "function.target.scope";
 /**
  * Function implementation
 */
 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, advisorSchemaService = swarm$1.advisorSchemaService.registry, outlineSchemaService = swarm$1.outlineSchemaService.registry, } = {}) => {
-    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$t);
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG && swarm$1.loggerService.log(METHOD_NAME$u);
     return await SchemaContextService.runInContext(runFn, {
         registry: {
             agentSchemaService,
@@ -21497,20 +22064,20 @@ async function scope(runFn, options) {
  * Method name for the startPipeline operation.
  * @private
 */
-const METHOD_NAME$s = "function.target.startPipeline";
+const METHOD_NAME$t = "function.target.startPipeline";
 /**
  * Function implementation
 */
 const startPipelineInternal = beginContext(async (clientId, pipelineName, agentName, payload = {}) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$s, {
+        swarm$1.loggerService.log(METHOD_NAME$t, {
             clientId,
             pipelineName,
         });
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$s);
-    swarm$1.pipelineValidationService.validate(pipelineName, METHOD_NAME$s);
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$s);
-    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$s, clientId, await swarm$1.sessionValidationService.getSwarm(clientId));
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$t);
+    swarm$1.pipelineValidationService.validate(pipelineName, METHOD_NAME$t);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$t);
+    const currentAgentName = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$t, clientId, await swarm$1.sessionValidationService.getSwarm(clientId));
     if (currentAgentName !== agentName) {
         await changeToAgent(agentName, clientId);
     }
@@ -21555,13 +22122,13 @@ async function startPipeline(clientId, pipelineName, agentName, payload) {
 }
 
 /** @private Constant defining the method name for logging purposes*/
-const METHOD_NAME$r = "function.common.hasSession";
+const METHOD_NAME$s = "function.common.hasSession";
 /**
  * Function implementation
 */
 const hasSessionInternal = (clientId) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$r, { clientId });
+        swarm$1.loggerService.log(METHOD_NAME$s, { clientId });
     return swarm$1.sessionValidationService.hasSession(clientId);
 };
 /**
@@ -21576,22 +22143,22 @@ function hasSession(clientId) {
     return hasSessionInternal(clientId);
 }
 
-const METHOD_NAME$q = "function.common.getCheckBusy";
+const METHOD_NAME$r = "function.common.getCheckBusy";
 /**
  * Function implementation
 */
 const getCheckBusyInternal = beginContext(async (clientId) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$q, {
+        swarm$1.loggerService.log(METHOD_NAME$r, {
             clientId,
         });
     if (!swarm$1.sessionValidationService.hasSession(clientId)) {
         return false;
     }
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$q);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$r);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$q);
-    return await swarm$1.swarmPublicService.getCheckBusy(METHOD_NAME$q, clientId, swarmName);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$r);
+    return await swarm$1.swarmPublicService.getCheckBusy(METHOD_NAME$r, clientId, swarmName);
 });
 /**
  * Checks if the swarm associated with the given client ID is currently busy.
@@ -21602,20 +22169,20 @@ async function getCheckBusy(clientId) {
     return await getCheckBusyInternal(clientId);
 }
 
-const METHOD_NAME$p = "function.common.getAgentHistory";
+const METHOD_NAME$q = "function.common.getAgentHistory";
 /**
  * Function implementation
  */
 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$p, {
+        swarm$1.loggerService.log(METHOD_NAME$q, {
             clientId,
             agentName,
         });
     // Validate the session and agent to ensure they exist and are accessible
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$p);
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$p);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$q);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$q);
     // Retrieve the agent's prompt configuration from the agent schema service
     const { prompt: upperPrompt } = swarm$1.agentSchemaService.get(agentName);
     const prompt = upperPrompt
@@ -21624,7 +22191,7 @@ const getAgentHistoryInternal = beginContext(async (clientId, agentName) => {
             : await upperPrompt(clientId, agentName)
         : "";
     // Fetch the agent's history using the prompt and rescue tweaks via the history public service
-    const history = await swarm$1.historyPublicService.toArrayForAgent(prompt, METHOD_NAME$p, clientId, agentName);
+    const history = await swarm$1.historyPublicService.toArrayForAgent(prompt, METHOD_NAME$q, clientId, agentName);
     // Return a shallow copy of the history array
     return [...history];
 });
@@ -21647,17 +22214,17 @@ async function getAgentHistory(clientId, agentName) {
     return await getAgentHistoryInternal(clientId, agentName);
 }
 
-const METHOD_NAME$o = "function.common.getSessionMode";
+const METHOD_NAME$p = "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$o, {
+        swarm$1.loggerService.log(METHOD_NAME$p, {
             clientId,
         });
     // Validate the session and swarm to ensure they exist and are accessible
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$o);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$p);
     const swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$o);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$p);
     // Retrieve the session mode from the session validation service
     return swarm$1.sessionValidationService.getSessionMode(clientId);
 });
@@ -21679,14 +22246,14 @@ async function getSessionMode(clientId) {
     return await getSessionModeInternal(clientId);
 }
 
-const METHOD_NAME$n = "function.common.getSessionContext";
+const METHOD_NAME$o = "function.common.getSessionContext";
 /**
  * Function implementation
 */
 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$n);
+        swarm$1.loggerService.log(METHOD_NAME$o);
     // Determine the method context, if active
     const methodContext = MethodContextService.hasContext()
         ? swarm$1.methodContextService.context
@@ -21725,17 +22292,17 @@ async function getSessionContext() {
  * @private Constant defining the method name for logging purposes.
  * Used as an identifier in log messages to track calls to `getNavigationRoute`.
 */
-const METHOD_NAME$m = "function.common.getNavigationRoute";
+const METHOD_NAME$n = "function.common.getNavigationRoute";
 /**
  * Function implementation
 */
 const getNavigationRouteInternal = (clientId, swarmName) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$m, {
+        swarm$1.loggerService.log(METHOD_NAME$n, {
             clientId,
             swarmName,
         });
-    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$m);
+    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$n);
     return swarm$1.navigationValidationService.getNavigationRoute(clientId, swarmName);
 };
 /**
@@ -21753,7 +22320,7 @@ function getNavigationRoute(clientId, swarmName) {
  * Provides a utility to retrieve the model-facing name of a tool for a given agent and client context.
  * Validates tool and agent existence, logs the operation if enabled, and supports both static and dynamic tool name resolution.
 */
-const METHOD_NAME$l = "function.common.getToolNameForModel";
+const METHOD_NAME$m = "function.common.getToolNameForModel";
 /**
  * Internal implementation for resolving the model-facing tool name.
  * Validates the tool and agent, logs the operation, and invokes the tool schema's function property if dynamic.
@@ -21762,13 +22329,13 @@ const METHOD_NAME$l = "function.common.getToolNameForModel";
 */
 const getToolNameForModelInternal = beginContext(async (toolName, clientId, agentName) => {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$l, {
+        swarm$1.loggerService.log(METHOD_NAME$m, {
             toolName,
             clientId,
             agentName,
         });
-    swarm$1.toolValidationService.validate(toolName, METHOD_NAME$l);
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$l);
+    swarm$1.toolValidationService.validate(toolName, METHOD_NAME$m);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$m);
     const { function: fn } = swarm$1.toolSchemaService.get(toolName);
     if (typeof fn === "function") {
         const { name } = await fn(clientId, agentName);
@@ -21791,18 +22358,18 @@ async function getToolNameForModel(toolName, clientId, agentName) {
     return await getToolNameForModelInternal(toolName, clientId, agentName);
 }
 
-const METHOD_NAME$k = "function.history.getUserHistory";
+const METHOD_NAME$l = "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$k, {
+        swarm$1.loggerService.log(METHOD_NAME$l, {
             clientId,
         });
     // Fetch raw history and filter for user role and mode
-    const history = await getRawHistoryInternal(clientId, METHOD_NAME$k);
+    const history = await getRawHistoryInternal(clientId, METHOD_NAME$l);
     return history.filter(({ role, mode }) => role === "user" && mode === "user");
 });
 /**
@@ -21823,18 +22390,18 @@ async function getUserHistory(clientId) {
     return await getUserHistoryInternal(clientId);
 }
 
-const METHOD_NAME$j = "function.history.getAssistantHistory";
+const METHOD_NAME$k = "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$j, {
+        swarm$1.loggerService.log(METHOD_NAME$k, {
             clientId,
         });
     // Fetch raw history and filter for assistant role
-    const history = await getRawHistoryInternal(clientId, METHOD_NAME$j);
+    const history = await getRawHistoryInternal(clientId, METHOD_NAME$k);
     return history.filter(({ role }) => role === "assistant");
 });
 /**
@@ -21855,18 +22422,18 @@ async function getAssistantHistory(clientId) {
     return await getAssistantHistoryInternal(clientId);
 }
 
-const METHOD_NAME$i = "function.history.getLastAssistantMessage";
+const METHOD_NAME$j = "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$i, {
+        swarm$1.loggerService.log(METHOD_NAME$j, {
             clientId,
         });
     // Fetch raw history and find the last assistant message
-    const history = await getRawHistoryInternal(clientId, METHOD_NAME$i);
+    const history = await getRawHistoryInternal(clientId, METHOD_NAME$j);
     const last = history.findLast(({ role }) => role === "assistant");
     return last?.content ? last.content : null;
 });
@@ -21888,18 +22455,18 @@ async function getLastAssistantMessage(clientId) {
     return await getLastAssistantMessageInternal(clientId);
 }
 
-const METHOD_NAME$h = "function.history.getLastSystemMessage";
+const METHOD_NAME$i = "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$h, {
+        swarm$1.loggerService.log(METHOD_NAME$i, {
             clientId,
         });
     // Fetch raw history and find the last system message
-    const history = await getRawHistoryInternal(clientId, METHOD_NAME$h);
+    const history = await getRawHistoryInternal(clientId, METHOD_NAME$i);
     const last = history.findLast(({ role }) => role === "system");
     return last ? last.content : null;
 });
@@ -21921,6 +22488,39 @@ async function getLastSystemMessage(clientId) {
     return await getLastSystemMessageInternal(clientId);
 }
 
+const METHOD_NAME$h = "function.history.getLastToolMessage";
+/**
+ * Function implementation
+*/
+const getLastToolMessageInternal = 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$h, {
+            clientId,
+        });
+    // Fetch raw history and find the last tool message
+    const history = await getRawHistoryInternal(clientId, METHOD_NAME$h);
+    const last = history.findLast(({ role }) => role === "tool");
+    return last?.content ? last.content : null;
+});
+/**
+ * Retrieves the content of the most recent tool message from a client's session history.
+ *
+ * This function fetches the raw history for a specified client using `getRawHistory` and finds the last entry where the role is "tool".
+ * It is wrapped in `beginContext` for a clean execution environment and logs the operation if enabled via `GLOBAL_CONFIG`. The result is the content
+ * of the last tool message as a string, or `null` if no tool message exists in the history.
+ *
+ *
+ * @param {string} clientId - The unique identifier of the client session.
+ * @throws {Error} If `getRawHistory` fails due to session validation or history retrieval issues.
+ * @example
+ * const lastMessage = await getLastToolMessage("client-123");
+ * console.log(lastMessage); // Outputs the last tool message or null
+*/
+async function getLastToolMessage(clientId) {
+    return await getLastToolMessageInternal(clientId);
+}
+
 const METHOD_NAME$g = "function.dump.getAgent";
 /**
  * Retrieves an agent schema by its name from the swarm's agent schema service.
@@ -21969,7 +22569,7 @@ function getCompute(computeName) {
     return swarm$1.computeSchemaService.get(computeName);
 }
 
-const METHOD_NAME$d = "function.dump.getEmbeding";
+const METHOD_NAME$d = "function.dump.getEmbedding";
 /**
  * Retrieves an embedding schema by its name from the swarm's embedding schema service.
  * Logs the operation if logging is enabled in the global configuration.
@@ -21977,7 +22577,7 @@ const METHOD_NAME$d = "function.dump.getEmbeding";
  * @function getEmbedding
  * @param {EmbeddingName} embeddingName - The name of the embedding.
 */
-function getEmbeding(embeddingName) {
+function getEmbedding(embeddingName) {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
         swarm$1.loggerService.log(METHOD_NAME$d, {
             embeddingName,
@@ -22113,7 +22713,7 @@ function getAdvisor(advisorName) {
     return swarm$1.advisorSchemaService.get(advisorName);
 }
 
-const METHOD_NAME$4 = "function.event.listenEvent";
+const METHOD_NAME$4 = "function.event.event";
 /**
  * Set of reserved event source names that cannot be used for custom events.
  * @constant {Set<EventSource>}
@@ -22218,7 +22818,16 @@ const listenEventInternal = beginContext((clientId, topicName, fn) => {
     // Validate the client ID
     validateClientId$g(clientId);
     // Subscribe to the event with a queued callback
-    return swarm$1.busService.subscribe(clientId, topicName, queued(async ({ payload }) => await fn(payload)));
+    return swarm$1.busService.subscribe(clientId, topicName, queued(async ({ payload }) => {
+        try {
+            // A throwing listener must not reject the queued chain: that surfaces
+            // as an unhandled rejection and can crash the host process.
+            return await fn(payload);
+        }
+        catch (error) {
+            console.error(`agent-swarm event listener error source=${METHOD_NAME$3} error=${getErrorMessage(error)}`);
+        }
+    }));
 });
 /**
  * Subscribes to a custom event on the swarm bus service and executes a callback when the event is received.
@@ -22291,7 +22900,16 @@ const listenEventOnceInternal = beginContext((clientId, topicName, filterFn, fn)
     // 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), queued(async ({ payload }) => await fn(payload)));
+    return swarm$1.busService.once(clientId, topicName, ({ payload }) => filterFn(payload), queued(async ({ payload }) => {
+        try {
+            // A throwing listener must not reject the queued chain: that surfaces
+            // as an unhandled rejection and can crash the host process.
+            return await fn(payload);
+        }
+        catch (error) {
+            console.error(`agent-swarm event listener error source=${METHOD_NAME$2} error=${getErrorMessage(error)}`);
+        }
+    }));
 });
 /**
  * Subscribes to a custom event on the swarm bus service for a single occurrence, executing a callback when the event matches a filter.
@@ -22332,7 +22950,11 @@ const METHOD_NAME$1 = "function.navigate.changeToPrevAgent";
  * @function
 */
 const createChangeToPrevAgent = memoize(([clientId]) => `${clientId}`, (clientId) => queued(async (methodName, agentName, swarmName) => {
-    if (!swarm$1.navigationValidationService.shouldNavigate(agentName, clientId, swarmName)) {
+    // Going back is legitimate by definition and naturally bounded by the
+    // depth of the navigation stack, so the recursion route guard does not
+    // apply here. Only a no-op transition to the current agent is skipped.
+    const activeAgent = await swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1, clientId, swarmName);
+    if (agentName === activeAgent) {
         return false;
     }
     // Notify all agents in the swarm of the change
@@ -22437,7 +23059,16 @@ const listenAgentEvent = beginContext((clientId, fn) => {
     // Validate the client ID
     validateClientId$e(clientId);
     // Subscribe to agent events with a queued callback
-    return swarm$1.busService.subscribe(clientId, "agent-bus", queued(async (e) => await fn(e)));
+    return swarm$1.busService.subscribe(clientId, "agent-bus", queued(async (e) => {
+        try {
+            // A throwing listener must not reject the queued chain: that surfaces
+            // as an unhandled rejection and can crash the host process.
+            return await fn(e);
+        }
+        catch (error) {
+            console.error(`agent-swarm event listener error source=listenAgentEvent error=${getErrorMessage(error)}`);
+        }
+    }));
 });
 
 /**
@@ -22475,7 +23106,16 @@ const listenHistoryEvent = beginContext((clientId, fn) => {
     // Validate the client ID
     validateClientId$d(clientId);
     // Subscribe to history events with a queued callback
-    return swarm$1.busService.subscribe(clientId, "history-bus", queued(async (e) => await fn(e)));
+    return swarm$1.busService.subscribe(clientId, "history-bus", queued(async (e) => {
+        try {
+            // A throwing listener must not reject the queued chain: that surfaces
+            // as an unhandled rejection and can crash the host process.
+            return await fn(e);
+        }
+        catch (error) {
+            console.error(`agent-swarm event listener error source=listenHistoryEvent error=${getErrorMessage(error)}`);
+        }
+    }));
 });
 
 /**
@@ -22513,7 +23153,16 @@ const listenSessionEvent = beginContext((clientId, fn) => {
     // Validate the client ID
     validateClientId$c(clientId);
     // Subscribe to session events with a queued callback
-    return swarm$1.busService.subscribe(clientId, "session-bus", queued(async (e) => await fn(e)));
+    return swarm$1.busService.subscribe(clientId, "session-bus", queued(async (e) => {
+        try {
+            // A throwing listener must not reject the queued chain: that surfaces
+            // as an unhandled rejection and can crash the host process.
+            return await fn(e);
+        }
+        catch (error) {
+            console.error(`agent-swarm event listener error source=listenSessionEvent error=${getErrorMessage(error)}`);
+        }
+    }));
 });
 
 /**
@@ -22551,7 +23200,16 @@ const listenStateEvent = beginContext((clientId, fn) => {
     // Validate the client ID
     validateClientId$b(clientId);
     // Subscribe to state events with a queued callback
-    return swarm$1.busService.subscribe(clientId, "state-bus", queued(async (e) => await fn(e)));
+    return swarm$1.busService.subscribe(clientId, "state-bus", queued(async (e) => {
+        try {
+            // A throwing listener must not reject the queued chain: that surfaces
+            // as an unhandled rejection and can crash the host process.
+            return await fn(e);
+        }
+        catch (error) {
+            console.error(`agent-swarm event listener error source=listenStateEvent error=${getErrorMessage(error)}`);
+        }
+    }));
 });
 
 /**
@@ -22589,7 +23247,16 @@ const listenStorageEvent = beginContext((clientId, fn) => {
     // Validate the client ID
     validateClientId$a(clientId);
     // Subscribe to storage events with a queued callback
-    return swarm$1.busService.subscribe(clientId, "storage-bus", queued(async (e) => await fn(e)));
+    return swarm$1.busService.subscribe(clientId, "storage-bus", queued(async (e) => {
+        try {
+            // A throwing listener must not reject the queued chain: that surfaces
+            // as an unhandled rejection and can crash the host process.
+            return await fn(e);
+        }
+        catch (error) {
+            console.error(`agent-swarm event listener error source=listenStorageEvent error=${getErrorMessage(error)}`);
+        }
+    }));
 });
 
 /**
@@ -22627,7 +23294,16 @@ const listenSwarmEvent = beginContext((clientId, fn) => {
     // Validate the client ID
     validateClientId$9(clientId);
     // Subscribe to swarm events with a queued callback
-    return swarm$1.busService.subscribe(clientId, "swarm-bus", queued(async (e) => await fn(e)));
+    return swarm$1.busService.subscribe(clientId, "swarm-bus", queued(async (e) => {
+        try {
+            // A throwing listener must not reject the queued chain: that surfaces
+            // as an unhandled rejection and can crash the host process.
+            return await fn(e);
+        }
+        catch (error) {
+            console.error(`agent-swarm event listener error source=listenSwarmEvent error=${getErrorMessage(error)}`);
+        }
+    }));
 });
 
 /**
@@ -22665,7 +23341,16 @@ const listenPolicyEvent = beginContext((clientId, fn) => {
     // Validate the client ID
     validateClientId$8(clientId);
     // Subscribe to policy events with a queued callback
-    return swarm$1.busService.subscribe(clientId, "policy-bus", queued(async (e) => await fn(e)));
+    return swarm$1.busService.subscribe(clientId, "policy-bus", queued(async (e) => {
+        try {
+            // A throwing listener must not reject the queued chain: that surfaces
+            // as an unhandled rejection and can crash the host process.
+            return await fn(e);
+        }
+        catch (error) {
+            console.error(`agent-swarm event listener error source=listenPolicyEvent error=${getErrorMessage(error)}`);
+        }
+    }));
 });
 
 /**
@@ -22708,7 +23393,16 @@ const listenAgentEventOnce = beginContext((clientId, filterFn, fn) => {
     // Validate the client ID
     validateClientId$7(clientId);
     // Subscribe to agent events for one occurrence with a filter and queued callback
-    return swarm$1.busService.once(clientId, "agent-bus", filterFn, queued(async (e) => await fn(e)));
+    return swarm$1.busService.once(clientId, "agent-bus", filterFn, queued(async (e) => {
+        try {
+            // A throwing listener must not reject the queued chain: that surfaces
+            // as an unhandled rejection and can crash the host process.
+            return await fn(e);
+        }
+        catch (error) {
+            console.error(`agent-swarm event listener error source=listenAgentEventOnce error=${getErrorMessage(error)}`);
+        }
+    }));
 });
 
 /**
@@ -22751,7 +23445,16 @@ const listenHistoryEventOnce = beginContext((clientId, filterFn, fn) => {
     // Validate the client ID
     validateClientId$6(clientId);
     // Subscribe to history events for one occurrence with a filter and queued callback
-    return swarm$1.busService.once(clientId, "history-bus", filterFn, queued(async (e) => await fn(e)));
+    return swarm$1.busService.once(clientId, "history-bus", filterFn, queued(async (e) => {
+        try {
+            // A throwing listener must not reject the queued chain: that surfaces
+            // as an unhandled rejection and can crash the host process.
+            return await fn(e);
+        }
+        catch (error) {
+            console.error(`agent-swarm event listener error source=listenHistoryEventOnce error=${getErrorMessage(error)}`);
+        }
+    }));
 });
 
 /**
@@ -22794,7 +23497,16 @@ const listenSessionEventOnce = beginContext((clientId, filterFn, fn) => {
     // Validate the client ID
     validateClientId$5(clientId);
     // Subscribe to session events for one occurrence with a filter and queued callback
-    return swarm$1.busService.once(clientId, "session-bus", filterFn, queued(async (e) => await fn(e)));
+    return swarm$1.busService.once(clientId, "session-bus", filterFn, queued(async (e) => {
+        try {
+            // A throwing listener must not reject the queued chain: that surfaces
+            // as an unhandled rejection and can crash the host process.
+            return await fn(e);
+        }
+        catch (error) {
+            console.error(`agent-swarm event listener error source=listenSessionEventOnce error=${getErrorMessage(error)}`);
+        }
+    }));
 });
 
 /**
@@ -22837,7 +23549,16 @@ const listenStateEventOnce = beginContext((clientId, filterFn, fn) => {
     // Validate the client ID
     validateClientId$4(clientId);
     // Subscribe to state events for one occurrence with a filter and queued callback
-    return swarm$1.busService.once(clientId, "state-bus", filterFn, queued(async (e) => await fn(e)));
+    return swarm$1.busService.once(clientId, "state-bus", filterFn, queued(async (e) => {
+        try {
+            // A throwing listener must not reject the queued chain: that surfaces
+            // as an unhandled rejection and can crash the host process.
+            return await fn(e);
+        }
+        catch (error) {
+            console.error(`agent-swarm event listener error source=listenStateEventOnce error=${getErrorMessage(error)}`);
+        }
+    }));
 });
 
 /**
@@ -22880,7 +23601,16 @@ const listenStorageEventOnce = beginContext((clientId, filterFn, fn) => {
     // Validate the client ID
     validateClientId$3(clientId);
     // Subscribe to storage events for one occurrence with a filter and queued callback
-    return swarm$1.busService.once(clientId, "storage-bus", filterFn, queued(async (e) => await fn(e)));
+    return swarm$1.busService.once(clientId, "storage-bus", filterFn, queued(async (e) => {
+        try {
+            // A throwing listener must not reject the queued chain: that surfaces
+            // as an unhandled rejection and can crash the host process.
+            return await fn(e);
+        }
+        catch (error) {
+            console.error(`agent-swarm event listener error source=listenStorageEventOnce error=${getErrorMessage(error)}`);
+        }
+    }));
 });
 
 /**
@@ -22923,7 +23653,16 @@ const listenSwarmEventOnce = beginContext((clientId, filterFn, fn) => {
     // Validate the client ID
     validateClientId$2(clientId);
     // Subscribe to swarm events for one occurrence with a filter and queued callback
-    return swarm$1.busService.once(clientId, "swarm-bus", filterFn, queued(async (e) => await fn(e)));
+    return swarm$1.busService.once(clientId, "swarm-bus", filterFn, queued(async (e) => {
+        try {
+            // A throwing listener must not reject the queued chain: that surfaces
+            // as an unhandled rejection and can crash the host process.
+            return await fn(e);
+        }
+        catch (error) {
+            console.error(`agent-swarm event listener error source=listenSwarmEventOnce error=${getErrorMessage(error)}`);
+        }
+    }));
 });
 
 /**
@@ -22966,7 +23705,16 @@ const listenExecutionEventOnce = beginContext((clientId, filterFn, fn) => {
     // Validate the client ID
     validateClientId$1(clientId);
     // Subscribe to execution events for one occurrence with a filter and queued callback
-    return swarm$1.busService.once(clientId, "execution-bus", filterFn, queued(async (e) => await fn(e)));
+    return swarm$1.busService.once(clientId, "execution-bus", filterFn, queued(async (e) => {
+        try {
+            // A throwing listener must not reject the queued chain: that surfaces
+            // as an unhandled rejection and can crash the host process.
+            return await fn(e);
+        }
+        catch (error) {
+            console.error(`agent-swarm event listener error source=listenExecutionEventOnce error=${getErrorMessage(error)}`);
+        }
+    }));
 });
 
 /**
@@ -23009,7 +23757,16 @@ const listenPolicyEventOnce = beginContext((clientId, filterFn, fn) => {
     // Validate the client ID
     validateClientId(clientId);
     // Subscribe to policy events for one occurrence with a filter and queued callback
-    return swarm$1.busService.once(clientId, "policy-bus", filterFn, queued(async (e) => await fn(e)));
+    return swarm$1.busService.once(clientId, "policy-bus", filterFn, queued(async (e) => {
+        try {
+            // A throwing listener must not reject the queued chain: that surfaces
+            // as an unhandled rejection and can crash the host process.
+            return await fn(e);
+        }
+        catch (error) {
+            console.error(`agent-swarm event listener error source=listenPolicyEventOnce error=${getErrorMessage(error)}`);
+        }
+    }));
 });
 
 /** @private Constant for logging the call method in RoundRobin*/
@@ -23323,10 +24080,6 @@ class SharedStateUtils {
 */
 const SharedState = new SharedStateUtils();
 
-/** @constant {number} INACTIVITY_CHECK - Interval for checking inactivity in milliseconds (1 minute)*/
-const INACTIVITY_CHECK = 60 * 1000;
-/** @constant {number} INACTIVITY_TIMEOUT - Timeout duration for inactivity in milliseconds (15 minutes)*/
-const INACTIVITY_TIMEOUT = 15 * 60 * 1000;
 /**
  * @constant {Function} BEGIN_CHAT_FN
  * Function to begin a chat session
@@ -23386,7 +24139,7 @@ class ChatInstance {
                 clientId: this.clientId,
                 swarmName: this.swarmName,
             });
-        const isActive = now - this._lastActivity <= INACTIVITY_TIMEOUT;
+        const isActive = now - this._lastActivity <= GLOBAL_CONFIG.CC_CHAT_INACTIVITY_TIMEOUT;
         this.callbacks.onCheckActivity &&
             this.callbacks.onCheckActivity(this.clientId, this.swarmName, isActive, this._lastActivity);
         return isActive;
@@ -23453,13 +24206,20 @@ class ChatUtils {
             const handleCleanup = async () => {
                 const now = Date.now();
                 for (const chat of this._chats.values()) {
-                    if (await chat.checkLastActivity(now)) {
-                        continue;
+                    try {
+                        if (await chat.checkLastActivity(now)) {
+                            continue;
+                        }
+                        await chat.dispose();
+                    }
+                    catch (error) {
+                        // The cleanup interval is fire-and-forget: a throwing user callback
+                        // (onDispose, onCheckActivity) must not become an unhandled rejection.
+                        console.error(`agent-swarm chat cleanup error error=${getErrorMessage(error)}`);
                     }
-                    await chat.dispose();
                 }
             };
-            setInterval(handleCleanup, INACTIVITY_CHECK);
+            setInterval(handleCleanup, GLOBAL_CONFIG.CC_CHAT_INACTIVITY_CHECK);
         });
         /**
          * Gets or creates a chat instance for a client
@@ -23701,8 +24461,18 @@ class StorageUtils {
             if (!swarm$1.agentValidationService.hasStorage(payload.agentName, payload.storageName)) {
                 throw new Error(`agent-swarm StorageUtils ${payload.storageName} not registered in ${payload.agentName} (createNumericIndex)`);
             }
-            const { length } = await swarm$1.storagePublicService.list(METHOD_NAME_CREATE_NUMERIC_INDEX, payload.clientId, payload.storageName);
-            return length + 1;
+            const items = await swarm$1.storagePublicService.list(METHOD_NAME_CREATE_NUMERIC_INDEX, payload.clientId, payload.storageName);
+            // length + 1 collides with surviving ids once anything was removed
+            // (items [1,2,3] minus 1 -> length 2 -> next "3" overwrites live item 3),
+            // so the next index must come from the maximum numeric id instead.
+            let maxId = 0;
+            for (const { id } of items) {
+                const numericId = Number(id);
+                if (!Number.isNaN(numericId)) {
+                    maxId = Math.max(maxId, numericId);
+                }
+            }
+            return maxId + 1;
         });
         /**
          * Clears all items from the storage for a given client and agent.
@@ -24017,18 +24787,15 @@ class SchemaUtils {
                     data,
                 });
             const { mapKey = GLOBAL_CONFIG.CC_NAME_TO_TITLE, mapValue = (_, value) => value.slice(0, 50), } = map;
+            // objectFlat emits ["", ""] entries as structural separators; render them
+            // as blank lines instead of leaking "undefined: " into the model prompt.
+            const mapEntry = ([key, value]) => key ? `${mapKey(key)}: ${mapValue(key, String(value))}` : "";
             if (Array.isArray(data)) {
                 return data
-                    .map((item) => objectFlat(item)
-                    .map(([key, value]) => [mapKey(key), mapValue(key, String(value))])
-                    .map(([key, value]) => `${key}: ${value}`)
-                    .join("\n"))
+                    .map((item) => objectFlat(item).map(mapEntry).join("\n"))
                     .join(`\n\n\n\n`);
             }
-            return objectFlat(data)
-                .map(([key, value]) => [mapKey(key), mapValue(key, String(value))])
-                .map(([key, value]) => `${key}: ${value}`)
-                .join("\n");
+            return objectFlat(data).map(mapEntry).join("\n");
         };
     }
 }
@@ -24836,4 +25603,4 @@ const Utils = {
     PersistEmbeddingUtils,
 };
 
-export { Adapter, Chat, ChatInstance, Compute, ExecutionContextService, History, HistoryMemoryInstance, HistoryPersistInstance, Logger, LoggerInstance, MCP, MethodContextService, Operator, OperatorInstance, PayloadContextService, PersistAlive, PersistBase, PersistEmbedding, PersistList, PersistMemory, PersistPolicy, PersistState, PersistStorage, PersistSwarm, Policy, RoundRobin, Schema, SchemaContextService, SharedCompute, SharedState, SharedStorage, State, Storage, Utils, addAdvisor, addAgent, addAgentNavigation, addCommitAction, addCompletion, addCompute, addEmbedding, addFetchInfo, addMCP, addOutline, addPipeline, addPolicy, addState, addStorage, addSwarm, addTool, addTriageNavigation, ask, beginContext, cancelOutput, cancelOutputForce, changeToAgent, changeToDefaultAgent, changeToPrevAgent, chat, commitAssistantMessage, commitAssistantMessageForce, commitDeveloperMessage, commitDeveloperMessageForce, commitFlush, commitFlushForce, commitStopTools, commitStopToolsForce, commitSystemMessage, commitSystemMessageForce, commitToolOutput, commitToolOutputForce, commitToolRequest, commitToolRequestForce, commitUserMessage, commitUserMessageForce, complete, createCommitAction, createFetchInfo, createNavigateToAgent, createNavigateToTriageAgent, disposeConnection, dumpAdvisorResult, dumpAgent, dumpClientPerformance, dumpDocs, dumpOutlineResult, dumpPerfomance, dumpSwarm, emit, emitForce, event, execute, executeForce, fork, getAdvisor, getAgent, getAgentHistory, getAgentName, getAssistantHistory, getCheckBusy, getCompletion, getCompute, getEmbeding, getLastAssistantMessage, getLastSystemMessage, getLastUserMessage, getMCP, getNavigationRoute, getPayload, getPipeline, getPolicy, getRawHistory, getSessionContext, getSessionMode, getState, getStorage, getSwarm, getTool, getToolNameForModel, getUserHistory, hasNavigation, hasSession, json, listenAgentEvent, listenAgentEventOnce, listenEvent, listenEventOnce, listenExecutionEvent, listenExecutionEventOnce, listenHistoryEvent, listenHistoryEventOnce, listenPolicyEvent, listenPolicyEventOnce, listenSessionEvent, listenSessionEventOnce, listenStateEvent, listenStateEventOnce, listenStorageEvent, listenStorageEventOnce, listenSwarmEvent, listenSwarmEventOnce, makeAutoDispose, makeConnection, markOffline, markOnline, notify, notifyForce, overrideAdvisor, overrideAgent, overrideCompletion, overrideCompute, overrideEmbeding, overrideMCP, overrideOutline, overridePipeline, overridePolicy, overrideState, overrideStorage, overrideSwarm, overrideTool, runStateless, runStatelessForce, scope, session, setConfig, startPipeline, swarm, toJsonSchema, validate, validateToolArguments };
+export { Adapter, Chat, ChatInstance, Compute, ExecutionContextService, History, HistoryMemoryInstance, HistoryPersistInstance, Logger, LoggerInstance, MCP, MethodContextService, Operator, OperatorInstance, PayloadContextService, PersistAlive, PersistBase, PersistEmbedding, PersistList, PersistMemory, PersistPolicy, PersistState, PersistStorage, PersistSwarm, Policy, RoundRobin, Schema, SchemaContextService, SharedCompute, SharedState, SharedStorage, State, Storage, TOOL_PROTOCOL_PROMPT, Utils, addAdvisor, addAgent, addAgentNavigation, addCommitAction, addCompletion, addCompute, addEmbedding, addFetchInfo, addMCP, addOutline, addPipeline, addPolicy, addState, addStorage, addSwarm, addTool, addTriageNavigation, ask, beginContext, cancelOutput, cancelOutputForce, changeToAgent, changeToDefaultAgent, changeToPrevAgent, chat, commitAssistantMessage, commitAssistantMessageForce, commitDeveloperMessage, commitDeveloperMessageForce, commitFlush, commitFlushForce, commitStopTools, commitStopToolsForce, commitSystemMessage, commitSystemMessageForce, commitToolOutput, commitToolOutputForce, commitToolRequest, commitToolRequestForce, commitUserMessage, commitUserMessageForce, complete, createCommitAction, createFetchInfo, createNavigateToAgent, createNavigateToTriageAgent, disposeConnection, dumpAdvisorResult, dumpAgent, dumpClientPerformance, dumpDocs, dumpOutlineResult, dumpPerfomance, dumpSwarm, emit, emitForce, event, execute, executeForce, fork, getAdvisor, getAgent, getAgentHistory, getAgentName, getAssistantHistory, getCheckBusy, getCompletion, getCompute, getEmbedding, getLastAssistantMessage, getLastSystemMessage, getLastToolMessage, getLastUserMessage, getMCP, getNavigationRoute, getPayload, getPipeline, getPolicy, getRawHistory, getSessionContext, getSessionMode, getState, getStorage, getSwarm, getTool, getToolNameForModel, getUserHistory, hasNavigation, hasSession, json, listenAgentEvent, listenAgentEventOnce, listenEvent, listenEventOnce, listenExecutionEvent, listenExecutionEventOnce, listenHistoryEvent, listenHistoryEventOnce, listenPolicyEvent, listenPolicyEventOnce, listenSessionEvent, listenSessionEventOnce, listenStateEvent, listenStateEventOnce, listenStorageEvent, listenStorageEventOnce, listenSwarmEvent, listenSwarmEventOnce, makeAutoDispose, makeConnection, markOffline, markOnline, notify, notifyForce, overrideAdvisor, overrideAgent, overrideCompletion, overrideCompute, overrideEmbedding, overrideMCP, overrideOutline, overridePipeline, overridePolicy, overrideState, overrideStorage, overrideSwarm, overrideTool, runStateless, runStatelessForce, scope, session, setConfig, startPipeline, swarm, toJsonSchema, validate, validateToolArguments };