@agentforge/core 0.16.72 → 0.16.73

package/dist/index.cjs

@@ -3057,6 +3057,18 @@ function withCache(node, options = {}) {
   return createCachedNode(node, cache2, resolvedOptions);
 }
 
+// src/langgraph/middleware/controller-runtime.ts
+function createControlledNode(node, resolveControlValue, executeWithController) {
+  return async (state) => {
+    const controlValue = resolveControlValue(state);
+    return executeWithController(
+      state,
+      controlValue,
+      (nextState) => Promise.resolve(node(nextState))
+    );
+  };
+}
+
 // src/langgraph/middleware/rate-limiting.ts
 var TokenBucket = class {
   constructor(maxTokens, refillRate) {
@@ -3131,6 +3143,61 @@ var FixedWindow = class {
     this.windowStart = Date.now();
   }
 };
+function createRateLimiter(strategy, maxRequests, windowMs) {
+  switch (strategy) {
+    case "token-bucket":
+      return new TokenBucket(maxRequests, maxRequests / windowMs);
+    case "sliding-window":
+      return new SlidingWindow(maxRequests, windowMs);
+    case "fixed-window":
+      return new FixedWindow(maxRequests, windowMs);
+    default:
+      throw new Error(`Unknown rate limit strategy: ${strategy}`);
+  }
+}
+var RateLimiterRegistry = class {
+  constructor(maxRequests, windowMs, strategy, onRateLimitExceeded, onRateLimitReset) {
+    this.maxRequests = maxRequests;
+    this.windowMs = windowMs;
+    this.strategy = strategy;
+    this.onRateLimitExceeded = onRateLimitExceeded;
+    this.onRateLimitReset = onRateLimitReset;
+  }
+  limiters = /* @__PURE__ */ new Map();
+  async execute(state, key, executor) {
+    const limiter = this.getOrCreate(key);
+    if (!limiter.tryConsume()) {
+      this.onRateLimitExceeded?.(key);
+      throw new Error(`Rate limit exceeded for key: ${key}`);
+    }
+    return executor(state);
+  }
+  reset(key) {
+    if (key) {
+      this.resetLimiter(key, this.limiters.get(key));
+      return;
+    }
+    this.limiters.forEach((limiter, limiterKey) => {
+      this.resetLimiter(limiterKey, limiter);
+    });
+  }
+  getOrCreate(key) {
+    const existing = this.limiters.get(key);
+    if (existing) {
+      return existing;
+    }
+    const limiter = createRateLimiter(this.strategy, this.maxRequests, this.windowMs);
+    this.limiters.set(key, limiter);
+    return limiter;
+  }
+  resetLimiter(key, limiter) {
+    if (!limiter) {
+      return;
+    }
+    limiter.reset();
+    this.onRateLimitReset?.(key);
+  }
+};
 function withRateLimit(node, options) {
   const {
     maxRequests,
@@ -3140,35 +3207,18 @@ function withRateLimit(node, options) {
     onRateLimitReset,
     keyGenerator = () => "global"
   } = options;
-  const limiters = /* @__PURE__ */ new Map();
-  return async (state) => {
-    const key = keyGenerator(state);
-    if (!limiters.has(key)) {
-      let limiter2;
-      switch (strategy) {
-        case "token-bucket":
-          limiter2 = new TokenBucket(maxRequests, maxRequests / windowMs);
-          break;
-        case "sliding-window":
-          limiter2 = new SlidingWindow(maxRequests, windowMs);
-          break;
-        case "fixed-window":
-          limiter2 = new FixedWindow(maxRequests, windowMs);
-          break;
-        default:
-          throw new Error(`Unknown rate limit strategy: ${strategy}`);
-      }
-      limiters.set(key, limiter2);
-    }
-    const limiter = limiters.get(key);
-    if (!limiter.tryConsume()) {
-      if (onRateLimitExceeded) {
-        onRateLimitExceeded(key);
-      }
-      throw new Error(`Rate limit exceeded for key: ${key}`);
-    }
-    return await Promise.resolve(node(state));
-  };
+  const registry = new RateLimiterRegistry(
+    maxRequests,
+    windowMs,
+    strategy,
+    onRateLimitExceeded,
+    onRateLimitReset
+  );
+  return createControlledNode(
+    node,
+    keyGenerator,
+    (state, key, executor) => registry.execute(state, key, executor)
+  );
 }
 function createSharedRateLimiter(options) {
   const {
@@ -3178,55 +3228,23 @@ function createSharedRateLimiter(options) {
     onRateLimitExceeded,
     onRateLimitReset
   } = options;
-  const limiters = /* @__PURE__ */ new Map();
+  const registry = new RateLimiterRegistry(
+    maxRequests,
+    windowMs,
+    strategy,
+    onRateLimitExceeded,
+    onRateLimitReset
+  );
   return {
-    withRateLimit: (node, keyGenerator = (state) => "global") => {
-      return async (state) => {
-        const key = keyGenerator(state);
-        if (!limiters.has(key)) {
-          let limiter2;
-          switch (strategy) {
-            case "token-bucket":
-              limiter2 = new TokenBucket(maxRequests, maxRequests / windowMs);
-              break;
-            case "sliding-window":
-              limiter2 = new SlidingWindow(maxRequests, windowMs);
-              break;
-            case "fixed-window":
-              limiter2 = new FixedWindow(maxRequests, windowMs);
-              break;
-            default:
-              throw new Error(`Unknown rate limit strategy: ${strategy}`);
-          }
-          limiters.set(key, limiter2);
-        }
-        const limiter = limiters.get(key);
-        if (!limiter.tryConsume()) {
-          if (onRateLimitExceeded) {
-            onRateLimitExceeded(key);
-          }
-          throw new Error(`Rate limit exceeded for key: ${key}`);
-        }
-        return await Promise.resolve(node(state));
-      };
+    withRateLimit: (node, keyGenerator = () => "global") => {
+      return createControlledNode(
+        node,
+        keyGenerator,
+        (state, key, executor) => registry.execute(state, key, executor)
+      );
     },
     reset: (key) => {
-      if (key) {
-        const limiter = limiters.get(key);
-        if (limiter) {
-          limiter.reset();
-          if (onRateLimitReset) {
-            onRateLimitReset(key);
-          }
-        }
-      } else {
-        limiters.forEach((limiter, k) => {
-          limiter.reset();
-          if (onRateLimitReset) {
-            onRateLimitReset(k);
-          }
-        });
-      }
+      registry.reset(key);
     }
   };
 }
@@ -3400,7 +3418,7 @@ var ConcurrencyController = class {
     this.queue = [];
   }
 };
-function withConcurrency(node, options = {}) {
+function createConfiguredConcurrencyController(options = {}) {
   const {
     maxConcurrent = 1,
     maxQueueSize = 0,
@@ -3411,46 +3429,36 @@ function withConcurrency(node, options = {}) {
     onQueueFull,
     queueTimeout = 0
   } = options;
-  const controller = new ConcurrencyController(
-    maxConcurrent,
-    maxQueueSize,
-    onQueued,
-    onExecutionStart,
-    onExecutionComplete,
-    onQueueFull,
-    queueTimeout
-  );
-  return async (state) => {
-    const priority = priorityFn(state);
-    return controller.execute(state, priority, async (s) => await node(s));
+  return {
+    controller: new ConcurrencyController(
+      maxConcurrent,
+      maxQueueSize,
+      onQueued,
+      onExecutionStart,
+      onExecutionComplete,
+      onQueueFull,
+      queueTimeout
+    ),
+    priorityFn
   };
 }
-function createSharedConcurrencyController(options = {}) {
-  const {
-    maxConcurrent = 1,
-    maxQueueSize = 0,
-    priorityFn = () => "normal",
-    onQueued,
-    onExecutionStart,
-    onExecutionComplete,
-    onQueueFull,
-    queueTimeout = 0
-  } = options;
-  const controller = new ConcurrencyController(
-    maxConcurrent,
-    maxQueueSize,
-    onQueued,
-    onExecutionStart,
-    onExecutionComplete,
-    onQueueFull,
-    queueTimeout
+function withConcurrency(node, options = {}) {
+  const { controller, priorityFn } = createConfiguredConcurrencyController(options);
+  return createControlledNode(
+    node,
+    priorityFn,
+    (state, priority, executor) => controller.execute(state, priority, executor)
   );
+}
+function createSharedConcurrencyController(options = {}) {
+  const { controller, priorityFn } = createConfiguredConcurrencyController(options);
   return {
     withConcurrency: (node) => {
-      return async (state) => {
-        const priority = priorityFn(state);
-        return controller.execute(state, priority, async (s) => await node(s));
-      };
+      return createControlledNode(
+        node,
+        priorityFn,
+        (state, priority, executor) => controller.execute(state, priority, executor)
+      );
     },
     getStats: () => controller.getStats(),
     clear: () => controller.clear()

package/dist/index.js

@@ -2881,6 +2881,18 @@ function withCache(node, options = {}) {
   return createCachedNode(node, cache2, resolvedOptions);
 }
 
+// src/langgraph/middleware/controller-runtime.ts
+function createControlledNode(node, resolveControlValue, executeWithController) {
+  return async (state) => {
+    const controlValue = resolveControlValue(state);
+    return executeWithController(
+      state,
+      controlValue,
+      (nextState) => Promise.resolve(node(nextState))
+    );
+  };
+}
+
 // src/langgraph/middleware/rate-limiting.ts
 var TokenBucket = class {
   constructor(maxTokens, refillRate) {
@@ -2955,6 +2967,61 @@ var FixedWindow = class {
     this.windowStart = Date.now();
   }
 };
+function createRateLimiter(strategy, maxRequests, windowMs) {
+  switch (strategy) {
+    case "token-bucket":
+      return new TokenBucket(maxRequests, maxRequests / windowMs);
+    case "sliding-window":
+      return new SlidingWindow(maxRequests, windowMs);
+    case "fixed-window":
+      return new FixedWindow(maxRequests, windowMs);
+    default:
+      throw new Error(`Unknown rate limit strategy: ${strategy}`);
+  }
+}
+var RateLimiterRegistry = class {
+  constructor(maxRequests, windowMs, strategy, onRateLimitExceeded, onRateLimitReset) {
+    this.maxRequests = maxRequests;
+    this.windowMs = windowMs;
+    this.strategy = strategy;
+    this.onRateLimitExceeded = onRateLimitExceeded;
+    this.onRateLimitReset = onRateLimitReset;
+  }
+  limiters = /* @__PURE__ */ new Map();
+  async execute(state, key, executor) {
+    const limiter = this.getOrCreate(key);
+    if (!limiter.tryConsume()) {
+      this.onRateLimitExceeded?.(key);
+      throw new Error(`Rate limit exceeded for key: ${key}`);
+    }
+    return executor(state);
+  }
+  reset(key) {
+    if (key) {
+      this.resetLimiter(key, this.limiters.get(key));
+      return;
+    }
+    this.limiters.forEach((limiter, limiterKey) => {
+      this.resetLimiter(limiterKey, limiter);
+    });
+  }
+  getOrCreate(key) {
+    const existing = this.limiters.get(key);
+    if (existing) {
+      return existing;
+    }
+    const limiter = createRateLimiter(this.strategy, this.maxRequests, this.windowMs);
+    this.limiters.set(key, limiter);
+    return limiter;
+  }
+  resetLimiter(key, limiter) {
+    if (!limiter) {
+      return;
+    }
+    limiter.reset();
+    this.onRateLimitReset?.(key);
+  }
+};
 function withRateLimit(node, options) {
   const {
     maxRequests,
@@ -2964,35 +3031,18 @@ function withRateLimit(node, options) {
     onRateLimitReset,
     keyGenerator = () => "global"
   } = options;
-  const limiters = /* @__PURE__ */ new Map();
-  return async (state) => {
-    const key = keyGenerator(state);
-    if (!limiters.has(key)) {
-      let limiter2;
-      switch (strategy) {
-        case "token-bucket":
-          limiter2 = new TokenBucket(maxRequests, maxRequests / windowMs);
-          break;
-        case "sliding-window":
-          limiter2 = new SlidingWindow(maxRequests, windowMs);
-          break;
-        case "fixed-window":
-          limiter2 = new FixedWindow(maxRequests, windowMs);
-          break;
-        default:
-          throw new Error(`Unknown rate limit strategy: ${strategy}`);
-      }
-      limiters.set(key, limiter2);
-    }
-    const limiter = limiters.get(key);
-    if (!limiter.tryConsume()) {
-      if (onRateLimitExceeded) {
-        onRateLimitExceeded(key);
-      }
-      throw new Error(`Rate limit exceeded for key: ${key}`);
-    }
-    return await Promise.resolve(node(state));
-  };
+  const registry = new RateLimiterRegistry(
+    maxRequests,
+    windowMs,
+    strategy,
+    onRateLimitExceeded,
+    onRateLimitReset
+  );
+  return createControlledNode(
+    node,
+    keyGenerator,
+    (state, key, executor) => registry.execute(state, key, executor)
+  );
 }
 function createSharedRateLimiter(options) {
   const {
@@ -3002,55 +3052,23 @@ function createSharedRateLimiter(options) {
     onRateLimitExceeded,
     onRateLimitReset
   } = options;
-  const limiters = /* @__PURE__ */ new Map();
+  const registry = new RateLimiterRegistry(
+    maxRequests,
+    windowMs,
+    strategy,
+    onRateLimitExceeded,
+    onRateLimitReset
+  );
   return {
-    withRateLimit: (node, keyGenerator = (state) => "global") => {
-      return async (state) => {
-        const key = keyGenerator(state);
-        if (!limiters.has(key)) {
-          let limiter2;
-          switch (strategy) {
-            case "token-bucket":
-              limiter2 = new TokenBucket(maxRequests, maxRequests / windowMs);
-              break;
-            case "sliding-window":
-              limiter2 = new SlidingWindow(maxRequests, windowMs);
-              break;
-            case "fixed-window":
-              limiter2 = new FixedWindow(maxRequests, windowMs);
-              break;
-            default:
-              throw new Error(`Unknown rate limit strategy: ${strategy}`);
-          }
-          limiters.set(key, limiter2);
-        }
-        const limiter = limiters.get(key);
-        if (!limiter.tryConsume()) {
-          if (onRateLimitExceeded) {
-            onRateLimitExceeded(key);
-          }
-          throw new Error(`Rate limit exceeded for key: ${key}`);
-        }
-        return await Promise.resolve(node(state));
-      };
+    withRateLimit: (node, keyGenerator = () => "global") => {
+      return createControlledNode(
+        node,
+        keyGenerator,
+        (state, key, executor) => registry.execute(state, key, executor)
+      );
     },
     reset: (key) => {
-      if (key) {
-        const limiter = limiters.get(key);
-        if (limiter) {
-          limiter.reset();
-          if (onRateLimitReset) {
-            onRateLimitReset(key);
-          }
-        }
-      } else {
-        limiters.forEach((limiter, k) => {
-          limiter.reset();
-          if (onRateLimitReset) {
-            onRateLimitReset(k);
-          }
-        });
-      }
+      registry.reset(key);
     }
   };
 }
@@ -3224,7 +3242,7 @@ var ConcurrencyController = class {
     this.queue = [];
   }
 };
-function withConcurrency(node, options = {}) {
+function createConfiguredConcurrencyController(options = {}) {
   const {
     maxConcurrent = 1,
     maxQueueSize = 0,
@@ -3235,46 +3253,36 @@ function withConcurrency(node, options = {}) {
     onQueueFull,
     queueTimeout = 0
   } = options;
-  const controller = new ConcurrencyController(
-    maxConcurrent,
-    maxQueueSize,
-    onQueued,
-    onExecutionStart,
-    onExecutionComplete,
-    onQueueFull,
-    queueTimeout
-  );
-  return async (state) => {
-    const priority = priorityFn(state);
-    return controller.execute(state, priority, async (s) => await node(s));
+  return {
+    controller: new ConcurrencyController(
+      maxConcurrent,
+      maxQueueSize,
+      onQueued,
+      onExecutionStart,
+      onExecutionComplete,
+      onQueueFull,
+      queueTimeout
+    ),
+    priorityFn
   };
 }
-function createSharedConcurrencyController(options = {}) {
-  const {
-    maxConcurrent = 1,
-    maxQueueSize = 0,
-    priorityFn = () => "normal",
-    onQueued,
-    onExecutionStart,
-    onExecutionComplete,
-    onQueueFull,
-    queueTimeout = 0
-  } = options;
-  const controller = new ConcurrencyController(
-    maxConcurrent,
-    maxQueueSize,
-    onQueued,
-    onExecutionStart,
-    onExecutionComplete,
-    onQueueFull,
-    queueTimeout
+function withConcurrency(node, options = {}) {
+  const { controller, priorityFn } = createConfiguredConcurrencyController(options);
+  return createControlledNode(
+    node,
+    priorityFn,
+    (state, priority, executor) => controller.execute(state, priority, executor)
   );
+}
+function createSharedConcurrencyController(options = {}) {
+  const { controller, priorityFn } = createConfiguredConcurrencyController(options);
   return {
     withConcurrency: (node) => {
-      return async (state) => {
-        const priority = priorityFn(state);
-        return controller.execute(state, priority, async (s) => await node(s));
-      };
+      return createControlledNode(
+        node,
+        priorityFn,
+        (state, priority, executor) => controller.execute(state, priority, executor)
+      );
     },
     getStats: () => controller.getStats(),
     clear: () => controller.clear()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentforge/core",
-  "version": "0.16.72",
+  "version": "0.16.73",
   "description": "Production-ready TypeScript agent framework built on LangGraph with orchestration, middleware, and typed abstractions.",
   "type": "module",
   "main": "./dist/index.cjs",