agent-swarm-kit 1.0.191 → 1.0.193

package/build/index.cjs

@@ -16630,84 +16630,43 @@ const METHOD_NAME_CALL = "RoundRobin.call";
 /** @private Constant for logging the create method in RoundRobin */
 const METHOD_NAME_CREATE = "RoundRobin.create";
 /**
- * A generic RoundRobin implementation that distributes calls across a set of tokens
- * using a factory function to create instances.
- * @template T The type of instances created by the factory
- * @template Token The type of tokens to cycle through
- * @template A The type of arguments passed to the factory (extends any[])
+ * A generic RoundRobin implementation that cycles through token-based instance creators.
+ * @template T The type of instances created
+ * @template Token The type of tokens
+ * @template A The type of arguments (extends any[])
  */
 class RoundRobin {
-    /**
-     * Creates a new RoundRobin instance
-     * @private
-     * @param tokens - Array of tokens to cycle through
-     * @param factory - Function that creates instances given a token and arguments
-     * @throws {Error} If the tokens array is empty
-     */
     constructor(tokens, factory) {
-        if (tokens.length === 0) {
-            throw new Error("agent-swarm RoundRobin cannot be created with an empty tokens array");
-        }
-        this.tokens = tokens;
-        this.factory = factory;
-        this.instances = new Map();
         this.currentIndex = 0;
+        this.tokens = tokens;
+        this.instances = new Map(tokens.map((token) => [token, factory(token)]));
     }
     /**
      * Creates a RoundRobin function that cycles through tokens
-     * @template T The type of instances created by the factory
-     * @template Token The type of tokens to cycle through
-     * @template A The type of arguments passed to the factory
-     * @param tokens - Array of tokens to cycle through
-     * @param factory - Function that creates instances given a token and arguments
-     * @returns A function that returns the next instance in the rotation
-     * @throws {Error} If the tokens array is empty
-     * @example
-     * const rr = RoundRobin.create(['a', 'b'], (token) => ({ id: token }));
-     * const instance1 = rr(); // { id: 'a' }
-     * const instance2 = rr(); // { id: 'b' }
      * @example
-     * const rr2 = RoundRobin.create<number[]>([[1], [2]], (token) => token[0]);
-     * const num1 = rr2(); // 1
-     * const num2 = rr2(); // 2
+     * const rr = RoundRobin.create(['a', 'b'], (t) => () => ({ id: t }));
      */
     static create(tokens, factory) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log(METHOD_NAME_CREATE, {
                 tokenCount: tokens.length,
             });
-        const roundRobin = new RoundRobin(tokens.filter((value) => !!value), factory);
-        return (...args) => roundRobin.call(...args);
+        return new RoundRobin(tokens, factory).call.bind(new RoundRobin(tokens, factory));
     }
-    /**
-     * Gets the next instance in the rotation, creating it if necessary
-     * @private
-     * @param args - Arguments to pass to the factory function
-     * @returns The next instance in the rotation
-     */
     call(...args) {
-        // Log the call
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log(METHOD_NAME_CALL, {
                 currentIndex: this.currentIndex,
                 tokenCount: this.tokens.length,
             });
-        // Get the current token
-        const token = this.tokens[this.currentIndex];
-        // Generate a map key (strings and symbols can be used directly, objects are stringified)
-        const key = typeof token === "object" && token !== null
-            ? JSON.stringify(token)
-            : token;
-        // Create instance if it doesn't exist
-        if (!this.instances.has(key)) {
-            const instance = this.factory(token, ...args);
-            this.instances.set(key, instance);
+        if (!this.tokens.length) {
+            throw new Error("agent-swarm RoundRobin requires non-empty tokens array");
         }
-        // Get the instance
-        const instance = this.instances.get(key);
-        // Update index for next call
+        const token = this.tokens[this.currentIndex];
+        const instance = this.instances.get(token);
+        const value = instance(...args);
         this.currentIndex = (this.currentIndex + 1) % this.tokens.length;
-        return instance;
+        return value;
     }
 }
 

package/build/index.mjs

@@ -16628,84 +16628,43 @@ const METHOD_NAME_CALL = "RoundRobin.call";
 /** @private Constant for logging the create method in RoundRobin */
 const METHOD_NAME_CREATE = "RoundRobin.create";
 /**
- * A generic RoundRobin implementation that distributes calls across a set of tokens
- * using a factory function to create instances.
- * @template T The type of instances created by the factory
- * @template Token The type of tokens to cycle through
- * @template A The type of arguments passed to the factory (extends any[])
+ * A generic RoundRobin implementation that cycles through token-based instance creators.
+ * @template T The type of instances created
+ * @template Token The type of tokens
+ * @template A The type of arguments (extends any[])
  */
 class RoundRobin {
-    /**
-     * Creates a new RoundRobin instance
-     * @private
-     * @param tokens - Array of tokens to cycle through
-     * @param factory - Function that creates instances given a token and arguments
-     * @throws {Error} If the tokens array is empty
-     */
     constructor(tokens, factory) {
-        if (tokens.length === 0) {
-            throw new Error("agent-swarm RoundRobin cannot be created with an empty tokens array");
-        }
-        this.tokens = tokens;
-        this.factory = factory;
-        this.instances = new Map();
         this.currentIndex = 0;
+        this.tokens = tokens;
+        this.instances = new Map(tokens.map((token) => [token, factory(token)]));
     }
     /**
      * Creates a RoundRobin function that cycles through tokens
-     * @template T The type of instances created by the factory
-     * @template Token The type of tokens to cycle through
-     * @template A The type of arguments passed to the factory
-     * @param tokens - Array of tokens to cycle through
-     * @param factory - Function that creates instances given a token and arguments
-     * @returns A function that returns the next instance in the rotation
-     * @throws {Error} If the tokens array is empty
-     * @example
-     * const rr = RoundRobin.create(['a', 'b'], (token) => ({ id: token }));
-     * const instance1 = rr(); // { id: 'a' }
-     * const instance2 = rr(); // { id: 'b' }
      * @example
-     * const rr2 = RoundRobin.create<number[]>([[1], [2]], (token) => token[0]);
-     * const num1 = rr2(); // 1
-     * const num2 = rr2(); // 2
+     * const rr = RoundRobin.create(['a', 'b'], (t) => () => ({ id: t }));
      */
     static create(tokens, factory) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log(METHOD_NAME_CREATE, {
                 tokenCount: tokens.length,
             });
-        const roundRobin = new RoundRobin(tokens.filter((value) => !!value), factory);
-        return (...args) => roundRobin.call(...args);
+        return new RoundRobin(tokens, factory).call.bind(new RoundRobin(tokens, factory));
     }
-    /**
-     * Gets the next instance in the rotation, creating it if necessary
-     * @private
-     * @param args - Arguments to pass to the factory function
-     * @returns The next instance in the rotation
-     */
     call(...args) {
-        // Log the call
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
             swarm$1.loggerService.log(METHOD_NAME_CALL, {
                 currentIndex: this.currentIndex,
                 tokenCount: this.tokens.length,
             });
-        // Get the current token
-        const token = this.tokens[this.currentIndex];
-        // Generate a map key (strings and symbols can be used directly, objects are stringified)
-        const key = typeof token === "object" && token !== null
-            ? JSON.stringify(token)
-            : token;
-        // Create instance if it doesn't exist
-        if (!this.instances.has(key)) {
-            const instance = this.factory(token, ...args);
-            this.instances.set(key, instance);
+        if (!this.tokens.length) {
+            throw new Error("agent-swarm RoundRobin requires non-empty tokens array");
         }
-        // Get the instance
-        const instance = this.instances.get(key);
-        // Update index for next call
+        const token = this.tokens[this.currentIndex];
+        const instance = this.instances.get(token);
+        const value = instance(...args);
         this.currentIndex = (this.currentIndex + 1) % this.tokens.length;
-        return instance;
+        return value;
     }
 }
 

package/package.json

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

package/types.d.ts

@@ -10257,58 +10257,26 @@ declare const GLOBAL_CONFIG: IGlobalConfig;
 declare const setConfig: (config: Partial<IGlobalConfig>) => void;
 
 /**
- * A generic RoundRobin implementation that distributes calls across a set of tokens
- * using a factory function to create instances.
- * @template T The type of instances created by the factory
- * @template Token The type of tokens to cycle through
- * @template A The type of arguments passed to the factory (extends any[])
+ * A generic RoundRobin implementation that cycles through token-based instance creators.
+ * @template T The type of instances created
+ * @template Token The type of tokens
+ * @template A The type of arguments (extends any[])
  */
 declare class RoundRobin<T, Token = string | symbol | {
     [key: string]: any;
 }, A extends any[] = any[]> {
-    /** @private Array of tokens to cycle through */
     private tokens;
-    /** @private Factory function that creates instances from tokens and arguments */
-    private factory;
-    /** @private Map storing created instances with string or symbol keys */
     private instances;
-    /** @private Current index position in the token rotation */
     private currentIndex;
-    /**
-     * Creates a new RoundRobin instance
-     * @private
-     * @param tokens - Array of tokens to cycle through
-     * @param factory - Function that creates instances given a token and arguments
-     * @throws {Error} If the tokens array is empty
-     */
     private constructor();
     /**
      * Creates a RoundRobin function that cycles through tokens
-     * @template T The type of instances created by the factory
-     * @template Token The type of tokens to cycle through
-     * @template A The type of arguments passed to the factory
-     * @param tokens - Array of tokens to cycle through
-     * @param factory - Function that creates instances given a token and arguments
-     * @returns A function that returns the next instance in the rotation
-     * @throws {Error} If the tokens array is empty
-     * @example
-     * const rr = RoundRobin.create(['a', 'b'], (token) => ({ id: token }));
-     * const instance1 = rr(); // { id: 'a' }
-     * const instance2 = rr(); // { id: 'b' }
      * @example
-     * const rr2 = RoundRobin.create<number[]>([[1], [2]], (token) => token[0]);
-     * const num1 = rr2(); // 1
-     * const num2 = rr2(); // 2
+     * const rr = RoundRobin.create(['a', 'b'], (t) => () => ({ id: t }));
      */
     static create<T, Token = string | symbol | {
         [key: string]: any;
-    }, A extends any[] = any[]>(tokens: Token[], factory: (token: Token, ...args: A) => T): (...args: A) => T;
-    /**
-     * Gets the next instance in the rotation, creating it if necessary
-     * @private
-     * @param args - Arguments to pass to the factory function
-     * @returns The next instance in the rotation
-     */
+    }, A extends any[] = any[]>(tokens: Token[], factory: (token: Token) => (...args: A) => T): (...args: A) => T;
     private call;
 }