agent-swarm-kit 4.0.0 → 5.0.0

package/package.json

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

package/types.d.ts

@@ -6139,8 +6139,18 @@ declare class ClientStorage<T extends IStorageData = IStorageData> implements IS
      */
     constructor(params: IStorageParams<T>);
     /**
-     * Dispatches a storage action (upsert, remove, or clear) in a queued manner, delegating to DISPATCH_FN.
-     * Ensures sequential execution of storage operations, supporting thread-safe updates from ClientAgent or tools.
+     * Queued core of dispatch. The wrapped function must never reject: queued()
+     * chains every call on the previous promise, so a rejection inside the queue
+     * (e.g. a throwing createIndex/createEmbedding/setData) would reject every
+     * already-queued dispatch with this foreign error WITHOUT running it — a
+     * concurrent upsert/remove/clear would be silently dropped. Errors are boxed
+     * here and rethrown outside the queue, so only the failing caller observes them.
+     */
+    private _dispatchQueue;
+    /**
+     * Dispatches a storage action (upsert, remove, or clear) through the serialized
+     * queue, delegating to DISPATCH_FN. Ensures sequential execution of storage
+     * operations, supporting thread-safe updates from ClientAgent or tools.
      */
     dispatch: (action: Action$1, payload: Partial<Payload<T>>) => Promise<void>;
     /**
@@ -6483,19 +6493,37 @@ declare class ClientState<State extends IStateData = IStateData> implements ISta
     readonly params: IStateParams<State>;
     readonly stateChanged: Subject<string>;
     /**
-     * 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.
+     * Marks the async execution context of a running dispatch (read/write).
+     * getState checks it to serve reentrant reads (getState called from INSIDE a
+     * setState dispatchFn/middleware) without re-entering the queue, which would
+     * deadlock. Scoping this per async-context — instead of a plain instance flag —
+     * ensures an UNRELATED concurrent getState still queues and observes writes in
+     * order, rather than reading a stale field while some other write is in flight.
+     */
+    private _dispatchContext;
+    /**
+     * True only while the caller runs inside the async context of an active
+     * dispatch on this instance (i.e. a reentrant call from within a dispatchFn).
      */
-    _inDispatch: boolean;
+    get _inDispatch(): boolean;
     /**
      * The current state data, initialized as null and set during waitForInit.
      * Updated by setState and clearState, persisted via params.setState if provided.
      */
     _state: State;
     /**
-     * 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.
+     * Queued core of dispatch. The wrapped function must never reject: queued()
+     * chains every call on the previous promise, so a rejection inside the queue
+     * would reject every already-queued dispatch with this foreign error WITHOUT
+     * running it — a concurrent setState would be silently dropped. Errors (e.g.
+     * a throwing user dispatchFn or middleware) are boxed here and rethrown
+     * outside the queue, so only the caller whose operation failed observes them.
+     */
+    private _dispatchQueue;
+    /**
+     * Dispatches a read or write of the state through the serialized queue,
+     * delegating to DISPATCH_FN. Ensures thread-safe state operations, supporting
+     * concurrent access from ClientAgent or tools.
      */
     dispatch: (action: Action, payload?: DispatchFn<State>) => Promise<State>;
     /**
@@ -7867,7 +7895,6 @@ declare class PolicyValidationService {
     validate: (policyName: PolicyName, source: string) => void;
 }
 
-declare const BAN_NEED_FETCH: unique symbol;
 /**
  * Class representing a client policy in the swarm system, implementing the IPolicy interface.
  * Manages client bans, input/output validation, and restrictions, with lazy-loaded ban lists and event emission via BusService.
@@ -7878,11 +7905,19 @@ declare const BAN_NEED_FETCH: unique symbol;
 declare class ClientPolicy implements IPolicy {
     readonly params: IPolicyParams;
     /**
-     * Set of banned client IDs or a symbol indicating the ban list needs to be fetched.
-     * Initialized as BAN_NEED_FETCH, lazily populated via params.getBannedClients on first use in hasBan, validateInput, etc.
-     * Updated by banClient and unbanClient, persisted if params.setBannedClients is provided.
+     * Ban sets keyed by swarm name, lazily populated via params.getBannedClients.
+     * A ClientPolicy instance is memoized per policyName and shared by every swarm
+     * that lists the policy, while bans are persisted per (policy, swarm) — a
+     * single shared set would leak bans of one swarm into another and persist
+     * the mixed set into the wrong store.
      */
-    _banSet: Set<SessionId> | typeof BAN_NEED_FETCH;
+    _banSetBySwarm: Map<string, Set<string>>;
+    /**
+     * Returns the ban set of the given swarm, fetching it on first access.
+     * Re-checks the map after the await: a ban committed through _banQueue while
+     * the fetch was in flight must not be overwritten by the stale fetch result.
+     */
+    private _getBanSet;
     /**
      * Serializes the read-modify-write of _banSet shared by banClient/unbanClient.
      * Without it two concurrent bans of different clients both read the same ban
@@ -7890,8 +7925,20 @@ declare class ClientPolicy implements IPolicy {
      * 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.
+     *
+     * The wrapped function must never reject: queued() chains every call on the
+     * previous promise, so a rejection inside the queue (e.g. a throwing
+     * setBannedClients adapter) would reject every already-queued ban/unban with
+     * this foreign error WITHOUT running it — a concurrent ban of another client
+     * would be silently lost. Errors are boxed here and rethrown by the caller
+     * outside the queue.
      */
     private _banQueue;
+    /**
+     * Runs a ban-set mutation through _banQueue, rethrowing its boxed error
+     * outside the queue so only the failing caller observes it.
+     */
+    private _runBanQueue;
     /**
      * Constructs a ClientPolicy instance with the provided parameters.
      * Invokes the onInit callback if defined and logs construction if debugging is enabled.