@agentforge/core 0.11.5 → 0.11.7

package/dist/index.cjs

@@ -91,6 +91,9 @@ __export(index_exports, {
   createProgressTracker: () => createProgressTracker,
   createSSEFormatter: () => createSSEFormatter,
   createSequentialWorkflow: () => createSequentialWorkflow,
+  createSharedCache: () => createSharedCache,
+  createSharedConcurrencyController: () => createSharedConcurrencyController,
+  createSharedRateLimiter: () => createSharedRateLimiter,
   createSqliteCheckpointer: () => createSqliteCheckpointer,
   createStateAnnotation: () => createStateAnnotation,
   createSubgraph: () => createSubgraph,
@@ -146,11 +149,16 @@ __export(index_exports, {
   validateTool: () => validateTool,
   validateToolMetadata: () => validateToolMetadata,
   validateToolName: () => validateToolName,
+  withCache: () => withCache,
+  withConcurrency: () => withConcurrency,
   withErrorHandler: () => withErrorHandler,
+  withLogging: () => withLogging,
   withMetrics: () => withMetrics,
+  withRateLimit: () => withRateLimit,
   withRetry: () => withRetry,
   withTimeout: () => withTimeout,
-  withTracing: () => withTracing
+  withTracing: () => withTracing,
+  withValidation: () => withValidation
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -2854,6 +2862,578 @@ var presets = {
   testing
 };
 
+// src/langgraph/middleware/caching.ts
+var LRUCache = class {
+  cache = /* @__PURE__ */ new Map();
+  maxSize;
+  evictionStrategy;
+  constructor(maxSize, evictionStrategy = "lru") {
+    this.maxSize = maxSize;
+    this.evictionStrategy = evictionStrategy;
+  }
+  get(key) {
+    const entry = this.cache.get(key);
+    if (!entry) return void 0;
+    entry.hits++;
+    entry.lastAccessed = Date.now();
+    return entry.value;
+  }
+  set(key, value) {
+    if (this.cache.size >= this.maxSize && !this.cache.has(key)) {
+      this.evict();
+    }
+    this.cache.set(key, {
+      value,
+      timestamp: Date.now(),
+      hits: 0,
+      lastAccessed: Date.now()
+    });
+  }
+  has(key) {
+    return this.cache.has(key);
+  }
+  delete(key) {
+    return this.cache.delete(key);
+  }
+  clear() {
+    this.cache.clear();
+  }
+  size() {
+    return this.cache.size;
+  }
+  evict() {
+    if (this.cache.size === 0) return;
+    let keyToEvict;
+    if (this.evictionStrategy === "lru") {
+      let oldestAccess = Infinity;
+      for (const [key, entry] of this.cache.entries()) {
+        if (entry.lastAccessed < oldestAccess) {
+          oldestAccess = entry.lastAccessed;
+          keyToEvict = key;
+        }
+      }
+    } else if (this.evictionStrategy === "lfu") {
+      let lowestHits = Infinity;
+      for (const [key, entry] of this.cache.entries()) {
+        if (entry.hits < lowestHits) {
+          lowestHits = entry.hits;
+          keyToEvict = key;
+        }
+      }
+    } else {
+      keyToEvict = this.cache.keys().next().value;
+    }
+    if (keyToEvict) {
+      this.cache.delete(keyToEvict);
+    }
+  }
+};
+function defaultKeyGenerator(state) {
+  try {
+    return JSON.stringify(state);
+  } catch {
+    return String(state);
+  }
+}
+function withCache(node, options = {}) {
+  const {
+    ttl = 36e5,
+    // 1 hour default
+    maxSize = 100,
+    evictionStrategy = "lru",
+    keyGenerator = defaultKeyGenerator,
+    cacheErrors = false,
+    onCacheHit,
+    onCacheMiss,
+    onEviction
+  } = options;
+  const cache2 = new LRUCache(maxSize, evictionStrategy);
+  return async (state) => {
+    const cacheKey = keyGenerator(state);
+    const cachedValue = cache2.get(cacheKey);
+    if (cachedValue !== void 0) {
+      const entry = cache2.cache.get(cacheKey);
+      const age = Date.now() - entry.timestamp;
+      if (age < ttl) {
+        if (onCacheHit) {
+          onCacheHit(cacheKey, cachedValue);
+        }
+        return cachedValue;
+      } else {
+        cache2.delete(cacheKey);
+        if (onEviction) {
+          onEviction(cacheKey, cachedValue);
+        }
+      }
+    }
+    if (onCacheMiss) {
+      onCacheMiss(cacheKey);
+    }
+    try {
+      const result = await Promise.resolve(node(state));
+      cache2.set(cacheKey, result);
+      return result;
+    } catch (error) {
+      if (cacheErrors && error instanceof Error) {
+        const errorResult = { error: error.message };
+        cache2.set(cacheKey, errorResult);
+      }
+      throw error;
+    }
+  };
+}
+function createSharedCache(options = {}) {
+  const {
+    ttl = 36e5,
+    maxSize = 100,
+    evictionStrategy = "lru",
+    cacheErrors = false,
+    onCacheHit,
+    onCacheMiss,
+    onEviction
+  } = options;
+  const cache2 = new LRUCache(maxSize, evictionStrategy);
+  return {
+    withCache: (node, keyGenerator = defaultKeyGenerator) => {
+      return async (state) => {
+        const cacheKey = keyGenerator(state);
+        const cachedValue = cache2.get(cacheKey);
+        if (cachedValue !== void 0) {
+          const entry = cache2.cache.get(cacheKey);
+          const age = Date.now() - entry.timestamp;
+          if (age < ttl) {
+            if (onCacheHit) {
+              onCacheHit(cacheKey, cachedValue);
+            }
+            return cachedValue;
+          } else {
+            cache2.delete(cacheKey);
+            if (onEviction) {
+              onEviction(cacheKey, cachedValue);
+            }
+          }
+        }
+        if (onCacheMiss) {
+          onCacheMiss(cacheKey);
+        }
+        try {
+          const result = await Promise.resolve(node(state));
+          cache2.set(cacheKey, result);
+          return result;
+        } catch (error) {
+          if (cacheErrors && error instanceof Error) {
+            const errorResult = { error: error.message };
+            cache2.set(cacheKey, errorResult);
+          }
+          throw error;
+        }
+      };
+    },
+    clear: () => cache2.clear(),
+    size: () => cache2.size()
+  };
+}
+
+// src/langgraph/middleware/rate-limiting.ts
+var TokenBucket = class {
+  constructor(maxTokens, refillRate) {
+    this.maxTokens = maxTokens;
+    this.refillRate = refillRate;
+    this.tokens = maxTokens;
+    this.lastRefill = Date.now();
+  }
+  tokens;
+  lastRefill;
+  tryConsume() {
+    this.refill();
+    if (this.tokens >= 1) {
+      this.tokens -= 1;
+      return true;
+    }
+    return false;
+  }
+  refill() {
+    const now = Date.now();
+    const timePassed = now - this.lastRefill;
+    const tokensToAdd = timePassed * this.refillRate;
+    this.tokens = Math.min(this.maxTokens, this.tokens + tokensToAdd);
+    this.lastRefill = now;
+  }
+  reset() {
+    this.tokens = this.maxTokens;
+    this.lastRefill = Date.now();
+  }
+};
+var SlidingWindow = class {
+  constructor(maxRequests, windowMs) {
+    this.maxRequests = maxRequests;
+    this.windowMs = windowMs;
+  }
+  requests = [];
+  tryConsume() {
+    const now = Date.now();
+    this.requests = this.requests.filter((timestamp) => now - timestamp < this.windowMs);
+    if (this.requests.length < this.maxRequests) {
+      this.requests.push(now);
+      return true;
+    }
+    return false;
+  }
+  reset() {
+    this.requests = [];
+  }
+};
+var FixedWindow = class {
+  constructor(maxRequests, windowMs) {
+    this.maxRequests = maxRequests;
+    this.windowMs = windowMs;
+    this.windowStart = Date.now();
+  }
+  count = 0;
+  windowStart;
+  tryConsume() {
+    const now = Date.now();
+    if (now - this.windowStart >= this.windowMs) {
+      this.count = 0;
+      this.windowStart = now;
+    }
+    if (this.count < this.maxRequests) {
+      this.count++;
+      return true;
+    }
+    return false;
+  }
+  reset() {
+    this.count = 0;
+    this.windowStart = Date.now();
+  }
+};
+function withRateLimit(node, options) {
+  const {
+    maxRequests,
+    windowMs,
+    strategy = "token-bucket",
+    onRateLimitExceeded,
+    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));
+  };
+}
+function createSharedRateLimiter(options) {
+  const {
+    maxRequests,
+    windowMs,
+    strategy = "token-bucket",
+    onRateLimitExceeded,
+    onRateLimitReset
+  } = options;
+  const limiters = /* @__PURE__ */ new Map();
+  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));
+      };
+    },
+    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);
+          }
+        });
+      }
+    }
+  };
+}
+
+// src/langgraph/middleware/validation.ts
+function withValidation(node, options) {
+  const {
+    inputSchema,
+    outputSchema,
+    inputValidator,
+    outputValidator,
+    mode = "both",
+    throwOnError = true,
+    onValidationError,
+    onValidationSuccess,
+    stripUnknown = false
+  } = options;
+  return async (state) => {
+    if (mode === "input" || mode === "both") {
+      try {
+        if (inputSchema) {
+          const validated = inputSchema.parse(state);
+          state = validated;
+        }
+        if (inputValidator) {
+          const isValid = await Promise.resolve(inputValidator(state));
+          if (!isValid) {
+            throw new Error("Input validation failed: custom validator returned false");
+          }
+        }
+        if (onValidationSuccess) {
+          onValidationSuccess(state, "input");
+        }
+      } catch (error) {
+        if (onValidationError) {
+          return onValidationError(error, state, "input");
+        }
+        if (throwOnError) {
+          throw error;
+        }
+        return state;
+      }
+    }
+    const result = await Promise.resolve(node(state));
+    if (mode === "output" || mode === "both") {
+      try {
+        if (outputSchema) {
+          const validated = outputSchema.parse(result);
+          if (onValidationSuccess) {
+            onValidationSuccess(validated, "output");
+          }
+          return validated;
+        }
+        if (outputValidator) {
+          const isValid = await Promise.resolve(outputValidator(result));
+          if (!isValid) {
+            throw new Error("Output validation failed: custom validator returned false");
+          }
+        }
+        if (onValidationSuccess) {
+          onValidationSuccess(result, "output");
+        }
+      } catch (error) {
+        if (onValidationError) {
+          return onValidationError(error, state, "output");
+        }
+        if (throwOnError) {
+          throw error;
+        }
+      }
+    }
+    return result;
+  };
+}
+
+// src/langgraph/middleware/concurrency.ts
+var ConcurrencyController = class {
+  constructor(maxConcurrent, maxQueueSize, onQueued, onExecutionStart, onExecutionComplete, onQueueFull, queueTimeout) {
+    this.maxConcurrent = maxConcurrent;
+    this.maxQueueSize = maxQueueSize;
+    this.onQueued = onQueued;
+    this.onExecutionStart = onExecutionStart;
+    this.onExecutionComplete = onExecutionComplete;
+    this.onQueueFull = onQueueFull;
+    this.queueTimeout = queueTimeout;
+  }
+  activeCount = 0;
+  queue = [];
+  async execute(state, priority, executor) {
+    if (this.activeCount < this.maxConcurrent) {
+      return this.executeTask(state, executor);
+    }
+    if (this.maxQueueSize > 0 && this.queue.length >= this.maxQueueSize) {
+      if (this.onQueueFull) {
+        this.onQueueFull(state);
+      }
+      throw new Error(`Queue is full (max size: ${this.maxQueueSize})`);
+    }
+    return new Promise((resolve, reject) => {
+      const task = {
+        state,
+        priority,
+        executor,
+        resolve,
+        reject,
+        timestamp: Date.now()
+      };
+      this.insertByPriority(task);
+      if (this.onQueued) {
+        this.onQueued(this.queue.length, state);
+      }
+      if (this.queueTimeout && this.queueTimeout > 0) {
+        setTimeout(() => {
+          const index = this.queue.indexOf(task);
+          if (index !== -1) {
+            this.queue.splice(index, 1);
+            reject(new Error(`Task timed out after ${this.queueTimeout}ms in queue`));
+          }
+        }, this.queueTimeout);
+      }
+    });
+  }
+  insertByPriority(task) {
+    const priorityOrder = { high: 0, normal: 1, low: 2 };
+    const taskPriorityValue = priorityOrder[task.priority];
+    let insertIndex = this.queue.length;
+    for (let i = 0; i < this.queue.length; i++) {
+      const queuedPriorityValue = priorityOrder[this.queue[i].priority];
+      if (taskPriorityValue < queuedPriorityValue) {
+        insertIndex = i;
+        break;
+      }
+    }
+    this.queue.splice(insertIndex, 0, task);
+  }
+  async executeTask(state, executor) {
+    this.activeCount++;
+    if (this.onExecutionStart) {
+      this.onExecutionStart(this.activeCount, state);
+    }
+    try {
+      const result = await executor(state);
+      if (this.onExecutionComplete) {
+        this.onExecutionComplete(this.activeCount - 1, state);
+      }
+      return result;
+    } finally {
+      this.activeCount--;
+      this.processQueue();
+    }
+  }
+  processQueue() {
+    if (this.queue.length === 0 || this.activeCount >= this.maxConcurrent) {
+      return;
+    }
+    const task = this.queue.shift();
+    if (task) {
+      this.executeTask(task.state, task.executor).then(task.resolve).catch(task.reject);
+    }
+  }
+  getStats() {
+    return {
+      activeCount: this.activeCount,
+      queueSize: this.queue.length
+    };
+  }
+  clear() {
+    this.queue.forEach((task) => {
+      task.reject(new Error("Queue cleared"));
+    });
+    this.queue = [];
+  }
+};
+function withConcurrency(node, 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
+  );
+  return async (state) => {
+    const priority = priorityFn(state);
+    return controller.execute(state, priority, async (s) => await node(s));
+  };
+}
+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
+  );
+  return {
+    withConcurrency: (node) => {
+      return async (state) => {
+        const priority = priorityFn(state);
+        return controller.execute(state, priority, async (s) => await node(s));
+      };
+    },
+    getStats: () => controller.getStats(),
+    clear: () => controller.clear()
+  };
+}
+
 // src/langgraph/persistence/checkpointer.ts
 var import_langgraph5 = require("@langchain/langgraph");
 function createMemoryCheckpointer(options) {
@@ -4413,6 +4993,9 @@ function createCircuitBreaker(options) {
   createProgressTracker,
   createSSEFormatter,
   createSequentialWorkflow,
+  createSharedCache,
+  createSharedConcurrencyController,
+  createSharedRateLimiter,
   createSqliteCheckpointer,
   createStateAnnotation,
   createSubgraph,
@@ -4468,9 +5051,14 @@ function createCircuitBreaker(options) {
   validateTool,
   validateToolMetadata,
   validateToolName,
+  withCache,
+  withConcurrency,
   withErrorHandler,
+  withLogging,
   withMetrics,
+  withRateLimit,
   withRetry,
   withTimeout,
-  withTracing
+  withTracing,
+  withValidation
 });