patch

Author: tripolskypetr

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-swarm-kit",
-  "version": "1.1.136",
+  "version": "1.1.137",
   "description": "A TypeScript library for building orchestrated framework-agnostic multi-agent AI systems",
   "author": {
     "name": "Petr Tripolsky",

package.json

@@ -185,13 +185,15 @@ export class ClientSession implements ISession {
         mode
       );
     const agent = await this.params.swarm.getAgent();
+    this.params.swarm.setBusy(true);
     const outputAwaiter = this.params.swarm.waitForOutput();
     agent.execute(message, mode);
     const output = await outputAwaiter;
     await swarm.executionValidationService.flushCount(
       this.params.clientId,
       this.params.swarmName,
     );
+    this.params.swarm.setBusy(false);
     if (
       await not(
         this.params.policy.validateOutput(

src/client/ClientSession.ts

@@ -16,8 +16,6 @@ import { IToolRequest } from "../model/Tool.model";
 const AGENT_NEED_FETCH = Symbol("agent-need-fetch");
 const STACK_NEED_FETCH = Symbol("stack-need-fetch");
 
-const SET_BUSY_FN = Symbol("set-busy-fn");
-
 /**
  * A no-operation (noop) agent that serves as a fallback when an agent is not found in the swarm.
  * Implements the {@link IAgent} interface and logs calls to its methods, indicating that the requested agent is unavailable,
@@ -235,8 +233,6 @@ const WAIT_FOR_OUTPUT_FN = async (self: ClientSwarm): Promise<string> => {
       `ClientSwarm swarmName=${self.params.swarmName} clientId=${self.params.clientId} waitForOutput`
     );
 
-  self[SET_BUSY_FN](true);
-
   const [awaiter, { resolve }] = createAwaiter<{
     agentName: AgentName;
     output: string;
@@ -293,8 +289,6 @@ const WAIT_FOR_OUTPUT_FN = async (self: ClientSwarm): Promise<string> => {
     clientId: self.params.clientId,
   });
 
-  self[SET_BUSY_FN](false);
-
   return output;
 };
 
@@ -329,10 +323,10 @@ export class ClientSwarm implements ISwarm {
    * Enables coordinated state management and debugging.
    * @param {boolean} isBusy - True to mark the swarm as busy, false to mark it as idle.
    */
-  public [SET_BUSY_FN](isBusy: boolean) {
+  public setBusy(isBusy: boolean) {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
       this.params.logger.debug(
-        `ClientSwarm swarmName=${this.params.swarmName} clientId=${this.params.clientId} setCheckBusy`,
+        `ClientSwarm swarmName=${this.params.swarmName} clientId=${this.params.clientId} setBusy`,
         { isBusy }
       );
     this._isBusy = isBusy;

src/client/ClientSwarm.ts

@@ -261,6 +261,15 @@ export interface ISwarm {
    * @returns {Promise<boolean>} True if the swarm is busy, false otherwise.
    */
   getCheckBusy(): Promise<boolean>;
+
+  /**
+   * Sets the busy state of the swarm.
+   * This method is used to indicate whether the swarm is currently processing an operation.
+   * It helps manage flow control and debugging by signaling when the swarm is occupied.
+   * @param {boolean} isBusy - True to mark the swarm as busy, false to mark it as idle.
+   * @throws {Error} If setting the busy state fails (e.g., due to internal errors).
+   */
+  setBusy(isBusy: boolean): void;
 }
 
 /**

src/interfaces/Swarm.interface.ts

@@ -166,6 +166,23 @@ export class SwarmConnectionService implements ISwarm {
     ).getCheckBusy();
   };
 
+  /**
+   * Sets the busy state of the swarm.
+   * Used to indicate whether the swarm is currently processing an operation, helping manage flow control and debugging.
+   * Delegates to ClientSwarm.setBusy, using context from MethodContextService, logging via LoggerService if GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO is true.
+   * Mirrors SwarmPublicService’s setBusy, supporting ClientAgent’s busy state management.
+   * @param {boolean} isBusy - True to mark the swarm as busy, false to mark it as idle.
+   * @returns {Promise<void>} A promise resolving when the busy state is set.
+   */
+  public setBusy = async (isBusy: boolean) => {
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO &&
+      this.loggerService.info(`swarmConnectionService setBusy`, { isBusy });
+    return await this.getSwarm(
+      this.methodContextService.context.clientId,
+      this.methodContextService.context.swarmName
+    ).setBusy(isBusy);
+  };
+
   /**
    * Cancels the pending output by emitting an empty string, interrupting waitForOutput.
    * Delegates to ClientSwarm.cancelOutput, using context from MethodContextService, logging via LoggerService if GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO is true.

src/lib/services/connection/SwarmConnectionService.ts

@@ -172,6 +172,46 @@ export class SwarmPublicService implements TSwarmConnectionService {
     );
   };
 
+  /**
+   * Sets the busy state of the swarm, indicating whether it is currently processing an operation.
+   * Wraps SwarmConnectionService.setBusy with MethodContextService, logging via LoggerService if GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO is true.
+   * Used in ClientAgent (e.g., marking swarm busy during EXECUTE_FN) and SessionPublicService (e.g., managing swarm state in connect).
+   * @param {boolean} isBusy - True to mark the swarm as busy, false to mark it as idle.
+   * @param {string} methodName - The method name for context and logging.
+   * @param {string} clientId - The client ID, scoping the operation to a specific client.
+   * @param {SwarmName} swarmName - The name of the swarm, used in SwarmMetaService context.
+   * @returns {Promise<void>} A promise resolving when the busy state is set.
+   */
+  public setBusy = async (
+    isBusy: boolean,
+    methodName: string,
+    clientId: string,
+    swarmName: SwarmName
+  ) => {
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO &&
+      this.loggerService.info("swarmPublicService setBusy", {
+        isBusy,
+        clientId,
+        swarmName,
+      });
+    return await MethodContextService.runInContext(
+      async () => {
+        return await this.swarmConnectionService.setBusy(isBusy);
+      },
+      {
+        methodName,
+        clientId,
+        swarmName,
+        policyName: "",
+        agentName: "",
+        storageName: "",
+        stateName: "",
+        mcpName: "",
+        computeName: "",
+      }
+    );
+  }
+
   /**
    * Cancels the await of output in the swarm by emitting an empty string, scoped to a client.
    * Wraps SwarmConnectionService.cancelOutput with MethodContextService, logging via LoggerService if GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO is true.

src/lib/services/public/SwarmPublicService.ts

@@ -1330,6 +1330,14 @@ interface ISwarm {
      * @returns {Promise<boolean>} True if the swarm is busy, false otherwise.
      */
     getCheckBusy(): Promise<boolean>;
+    /**
+     * Sets the busy state of the swarm.
+     * This method is used to indicate whether the swarm is currently processing an operation.
+     * It helps manage flow control and debugging by signaling when the swarm is occupied.
+     * @param {boolean} isBusy - True to mark the swarm as busy, false to mark it as idle.
+     * @throws {Error} If setting the busy state fails (e.g., due to internal errors).
+     */
+    setBusy(isBusy: boolean): void;
 }
 /**
  * Type representing the unique name of a swarm within the system.
@@ -4576,6 +4584,12 @@ declare class ClientAgent implements IAgent {
      * @returns {Promise<void>} Resolves when the message is committed and the event is emitted.
      */
     commitSystemMessage(message: string): Promise<void>;
+    /**
+     * Commits a developer message to the history, notifying the system via BusService without triggering execution.
+     * Useful for logging developer notes or debugging information, coordinated with SessionConnectionService.
+     * @param {string} message - The developer message to commit, trimmed before storage.
+     * @returns {Promise<void>} Resolves when the message is committed and the event is emitted.
+     */
     commitDeveloperMessage(message: string): Promise<void>;
     /**
      * Commits a tool request to the agent's history and emits an event via BusService.
@@ -5428,7 +5442,6 @@ declare class ToolSchemaService {
 
 declare const AGENT_NEED_FETCH: unique symbol;
 declare const STACK_NEED_FETCH: unique symbol;
-declare const SET_BUSY_FN: unique symbol;
 /**
  * Manages a collection of agents within a swarm in the swarm system, implementing the ISwarm interface.
  * Handles agent switching, output waiting, and navigation stack management, with queued operations and event-driven updates via BusService.
@@ -5453,7 +5466,7 @@ declare class ClientSwarm implements ISwarm {
      * Enables coordinated state management and debugging.
      * @param {boolean} isBusy - True to mark the swarm as busy, false to mark it as idle.
      */
-    [SET_BUSY_FN](isBusy: boolean): void;
+    setBusy(isBusy: boolean): void;
     /**
      * Subject that emits when an agent reference changes, providing the agent name and instance.
      * Used by setAgentRef to notify subscribers (e.g., waitForOutput) of updates to agent instances.
@@ -5643,6 +5656,15 @@ declare class SwarmConnectionService implements ISwarm {
      * @returns {Promise<boolean>} True if the swarm is busy, false otherwise.
      */
     getCheckBusy: () => Promise<boolean>;
+    /**
+     * Sets the busy state of the swarm.
+     * Used to indicate whether the swarm is currently processing an operation, helping manage flow control and debugging.
+     * Delegates to ClientSwarm.setBusy, using context from MethodContextService, logging via LoggerService if GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO is true.
+     * Mirrors SwarmPublicService’s setBusy, supporting ClientAgent’s busy state management.
+     * @param {boolean} isBusy - True to mark the swarm as busy, false to mark it as idle.
+     * @returns {Promise<void>} A promise resolving when the busy state is set.
+     */
+    setBusy: (isBusy: boolean) => Promise<void>;
     /**
      * Cancels the pending output by emitting an empty string, interrupting waitForOutput.
      * Delegates to ClientSwarm.cancelOutput, using context from MethodContextService, logging via LoggerService if GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO is true.
@@ -6777,6 +6799,17 @@ declare class SwarmPublicService implements TSwarmConnectionService {
      * @returns {Promise<boolean>} True if the swarm is busy, false otherwise.
      */
     getCheckBusy: (methodName: string, clientId: string, swarmName: SwarmName) => Promise<boolean>;
+    /**
+     * Sets the busy state of the swarm, indicating whether it is currently processing an operation.
+     * Wraps SwarmConnectionService.setBusy with MethodContextService, logging via LoggerService if GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO is true.
+     * Used in ClientAgent (e.g., marking swarm busy during EXECUTE_FN) and SessionPublicService (e.g., managing swarm state in connect).
+     * @param {boolean} isBusy - True to mark the swarm as busy, false to mark it as idle.
+     * @param {string} methodName - The method name for context and logging.
+     * @param {string} clientId - The client ID, scoping the operation to a specific client.
+     * @param {SwarmName} swarmName - The name of the swarm, used in SwarmMetaService context.
+     * @returns {Promise<void>} A promise resolving when the busy state is set.
+     */
+    setBusy: (isBusy: boolean, methodName: string, clientId: string, swarmName: SwarmName) => Promise<void>;
     /**
      * Cancels the await of output in the swarm by emitting an empty string, scoped to a client.
      * Wraps SwarmConnectionService.cancelOutput with MethodContextService, logging via LoggerService if GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO is true.