busy-fn

Author: tripolskypetr

package-lock.json

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

package.json

@@ -16,6 +16,8 @@ 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,
@@ -219,6 +221,8 @@ 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;
@@ -275,6 +279,8 @@ const WAIT_FOR_OUTPUT_FN = async (self: ClientSwarm): Promise<string> => {
     clientId: self.params.clientId,
   });
 
+  self[SET_BUSY_FN](false);
+
   return output;
 };
 
@@ -287,6 +293,37 @@ const WAIT_FOR_OUTPUT_FN = async (self: ClientSwarm): Promise<string> => {
  * @implements {ISwarm}
  */
 export class ClientSwarm implements ISwarm {
+  private _isBusy = false;
+
+  /**
+   * Returns the current busy state of the swarm.
+   * Used to check if the swarm is currently processing an operation (e.g., waiting for output or switching agents).
+   * Supports debugging and flow control in client applications.
+   * @returns {Promise<boolean>} True if the swarm is busy, false otherwise.
+   */
+  public getCheckBusy() {
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
+      this.params.logger.debug(
+        `ClientSwarm swarmName=${this.params.swarmName} clientId=${this.params.clientId} getCheckBusy`
+      );
+    return Promise.resolve(this._isBusy);
+  }
+
+  /**
+   * Sets the busy state of the swarm.
+   * Used internally to indicate when the swarm is processing an operation, such as waiting for output.
+   * 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) {
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
+      this.params.logger.debug(
+        `ClientSwarm swarmName=${this.params.swarmName} clientId=${this.params.clientId} setCheckBusy`,
+        { isBusy }
+      );
+    this._isBusy = isBusy;
+  }
+
   /**
    * 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.
@@ -424,8 +461,8 @@ export class ClientSwarm implements ISwarm {
       agentName: await this.getAgentName(),
       output: "",
     });
-    await Promise.all(this._agentList
-      .map(async ([, agent]) => {
+    await Promise.all(
+      this._agentList.map(async ([, agent]) => {
         await agent.commitCancelOutput();
       })
     );

src/client/ClientSwarm.ts

@@ -0,0 +1,35 @@
+import beginContext from "../../utils/beginContext";
+import { GLOBAL_CONFIG } from "../../config/params";
+import swarm from "../../lib";
+
+const METHOD_NAME = "function.common.getCheckBusy";
+
+/**
+ * Function implementation
+ */
+const getCheckBusyInternal = beginContext(async (clientId: string) => {
+  GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
+    swarm.loggerService.log(METHOD_NAME, {
+      clientId,
+    });
+
+  swarm.sessionValidationService.validate(clientId, METHOD_NAME);
+  const swarmName = swarm.sessionValidationService.getSwarm(clientId);
+  swarm.swarmValidationService.validate(swarmName, METHOD_NAME);
+
+  return await swarm.swarmPublicService.getCheckBusy(
+    METHOD_NAME,
+    clientId,
+    swarmName
+  );
+});
+
+/**
+ * Checks if the swarm associated with the given client ID is currently busy.
+ *
+ * @param {string} clientId - The unique identifier of the client whose swarm status is being checked.
+ * @returns {Promise<boolean>} A promise that resolves to true if the swarm is busy, or false otherwise.
+ */
+export async function getCheckBusy(clientId: string) {
+  return await getCheckBusyInternal(clientId);
+}

src/functions/common/getCheckBusy.ts

@@ -80,6 +80,7 @@ export * from "./functions/target/disposeConnection";
 export * from "./functions/common/hasSession";
 export * from "./functions/common/hasNavigation";
 export * from "./functions/common/getPayload";
+export * from "./functions/common/getCheckBusy";
 export * from "./functions/common/getAgentName";
 export * from "./functions/common/getAgentHistory";
 export * from "./functions/common/getSessionMode";

src/index.ts

@@ -253,6 +253,14 @@ export interface ISwarm {
    * @throws {Error} If the emission fails due to connection issues or invalid message format.
    */
   emit(message: string): Promise<void>;
+
+  /**
+   * Returns the current busy state of the swarm.
+   * Used to check if the swarm is currently processing an operation (e.g., waiting for output or switching agents).
+   * Supports debugging and flow control in client applications.
+   * @returns {Promise<boolean>} True if the swarm is busy, false otherwise.
+   */
+  getCheckBusy(): Promise<boolean>;
 }
 
 /**

src/interfaces/Swarm.interface.ts

@@ -151,6 +151,21 @@ export class SwarmConnectionService implements ISwarm {
     ).navigationPop();
   };
 
+  /**
+   * Returns the current busy state of the swarm.
+   * Used to check if the swarm is currently processing an operation (e.g., waiting for output or switching agents).
+   * Supports debugging and flow control in client applications.
+   * @returns {Promise<boolean>} True if the swarm is busy, false otherwise.
+   */
+  public getCheckBusy = async () => {
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO &&
+      this.loggerService.info(`swarmConnectionService getCheckBusy`);
+    return await this.getSwarm(
+      this.methodContextService.context.clientId,
+      this.methodContextService.context.swarmName
+    ).getCheckBusy();
+  };
+
   /**
    * 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

@@ -135,6 +135,43 @@ export class SwarmPublicService implements TSwarmConnectionService {
     );
   };
 
+  /**
+   * Returns the current busy state of the swarm.
+   * Used to check if the swarm is currently processing an operation (e.g., waiting for output or switching agents).
+   * Supports debugging and flow control in client applications.
+   * @param {string} methodName - The name of the method invoking the operation, logged and scoped in context.
+   * @param {string} clientId - The client ID, tying to ClientAgent sessions and PerfService tracking, scoping the operation to a specific client.
+   * @param {SwarmName} swarmName - The name of the swarm, sourced from Swarm.interface, used in SwarmMetaService context.
+   * @returns {Promise<boolean>} True if the swarm is busy, false otherwise.
+   */
+  public getCheckBusy = async (
+    methodName: string,
+    clientId: string,
+    swarmName: SwarmName
+  ) => {
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO &&
+      this.loggerService.info("swarmPublicService getCheckBusy", {
+        clientId,
+        swarmName,
+      });
+    return await MethodContextService.runInContext(
+      async () => {
+        return await this.swarmConnectionService.getCheckBusy();
+      },
+      {
+        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.