@agentforge/core 0.16.54 → 0.16.55

package/dist/index.cjs

@@ -2888,36 +2888,61 @@ var presets = {
   testing
 };
 
-// src/langgraph/middleware/caching.ts
+// src/langgraph/middleware/caching-options.ts
+function defaultCacheKeyGenerator(state) {
+  try {
+    return JSON.stringify(state);
+  } catch {
+    return String(state);
+  }
+}
+function resolveCachingOptions(options) {
+  return {
+    ttl: options.ttl ?? 36e5,
+    maxSize: options.maxSize ?? 100,
+    evictionStrategy: options.evictionStrategy ?? "lru",
+    keyGenerator: options.keyGenerator ?? defaultCacheKeyGenerator,
+    cacheErrors: options.cacheErrors ?? false,
+    onCacheHit: options.onCacheHit,
+    onCacheMiss: options.onCacheMiss,
+    onEviction: options.onEviction
+  };
+}
+function resolveSharedCacheKeyGenerator(keyGenerator) {
+  return keyGenerator ?? defaultCacheKeyGenerator;
+}
+
+// src/langgraph/middleware/caching-store.ts
 var LRUCache = class {
-  cache = /* @__PURE__ */ new Map();
-  maxSize;
-  evictionStrategy;
   constructor(maxSize, evictionStrategy = "lru") {
     this.maxSize = maxSize;
     this.evictionStrategy = evictionStrategy;
   }
+  cache = /* @__PURE__ */ new Map();
   get(key) {
     const entry = this.cache.get(key);
-    if (!entry) return void 0;
+    if (!entry) {
+      return void 0;
+    }
     entry.hits++;
     entry.lastAccessed = Date.now();
     return entry.value;
   }
+  getEntry(key) {
+    return this.cache.get(key);
+  }
   set(key, value) {
     if (this.cache.size >= this.maxSize && !this.cache.has(key)) {
       this.evict();
     }
+    const now = Date.now();
     this.cache.set(key, {
       value,
-      timestamp: Date.now(),
+      timestamp: now,
       hits: 0,
-      lastAccessed: Date.now()
+      lastAccessed: now
     });
   }
-  has(key) {
-    return this.cache.has(key);
-  }
   delete(key) {
     return this.cache.delete(key);
   }
@@ -2928,138 +2953,99 @@ var LRUCache = class {
     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 (this.cache.size === 0) {
+      return;
     }
-    if (keyToEvict) {
+    const keyToEvict = this.findKeyToEvict();
+    if (keyToEvict !== void 0) {
       this.cache.delete(keyToEvict);
     }
   }
+  findKeyToEvict() {
+    if (this.evictionStrategy === "fifo") {
+      return this.cache.keys().next().value;
+    }
+    let selectedKey;
+    let selectedValue = Infinity;
+    for (const [key, entry] of this.cache.entries()) {
+      const candidateValue = this.evictionStrategy === "lfu" ? entry.hits : entry.lastAccessed;
+      if (candidateValue < selectedValue) {
+        selectedValue = candidateValue;
+        selectedKey = key;
+      }
+    }
+    return selectedKey;
+  }
 };
-function defaultKeyGenerator(state) {
-  try {
-    return JSON.stringify(state);
-  } catch {
-    return String(state);
+
+// src/langgraph/middleware/caching-entry.ts
+function isFreshCacheEntry(entry, ttl) {
+  if (!entry) {
+    return false;
   }
+  return Date.now() - entry.timestamp < ttl;
 }
-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);
+function createCachedErrorResult(error) {
+  return { error: error.message };
+}
+
+// src/langgraph/middleware/caching-wrapper.ts
+function createCachedNode(node, cache2, options, keyGenerator = options.keyGenerator) {
   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);
-        }
-      }
+    const entry = cache2.getEntry(cacheKey);
+    if (cachedValue !== void 0 && isFreshCacheEntry(entry, options.ttl)) {
+      options.onCacheHit?.(cacheKey, cachedValue);
+      return cachedValue;
     }
-    if (onCacheMiss) {
-      onCacheMiss(cacheKey);
+    if (cachedValue !== void 0 && entry) {
+      cache2.delete(cacheKey);
+      options.onEviction?.(cacheKey, cachedValue);
     }
+    options.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);
+      if (options.cacheErrors && error instanceof Error) {
+        cache2.set(cacheKey, createCachedErrorResult(error));
       }
       throw error;
     }
   };
 }
+
+// src/langgraph/middleware/caching-shared.ts
 function createSharedCache(options = {}) {
-  const {
-    ttl = 36e5,
-    maxSize = 100,
-    evictionStrategy = "lru",
-    cacheErrors = false,
-    onCacheHit,
-    onCacheMiss,
-    onEviction
-  } = options;
-  const cache2 = new LRUCache(maxSize, evictionStrategy);
+  const resolvedOptions = resolveCachingOptions(options);
+  const cache2 = new LRUCache(
+    resolvedOptions.maxSize,
+    resolvedOptions.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;
-        }
-      };
-    },
+    withCache: (node, keyGenerator) => createCachedNode(
+      node,
+      cache2,
+      resolvedOptions,
+      resolveSharedCacheKeyGenerator(keyGenerator)
+    ),
     clear: () => cache2.clear(),
     size: () => cache2.size()
   };
 }
 
+// src/langgraph/middleware/caching.ts
+function withCache(node, options = {}) {
+  const resolvedOptions = resolveCachingOptions(options);
+  const cache2 = new LRUCache(
+    resolvedOptions.maxSize,
+    resolvedOptions.evictionStrategy
+  );
+  return createCachedNode(node, cache2, resolvedOptions);
+}
+
 // src/langgraph/middleware/rate-limiting.ts
 var TokenBucket = class {
   constructor(maxTokens, refillRate) {

package/dist/index.d.cts

@@ -2445,12 +2445,6 @@ interface TracingOptions {
  */
 declare function withTracing<State>(node: (state: State) => State | Promise<State> | Partial<State> | Promise<Partial<State>>, options: TracingOptions): (state: State) => Promise<State | Partial<State>>;
 
-/**
- * Caching Middleware for LangGraph Nodes
- *
- * Provides caching capabilities with TTL, LRU eviction, and custom key generation.
- */
-
 /**
  * Cache key generator function
  */
@@ -2464,54 +2458,68 @@ type EvictionStrategy = 'lru' | 'lfu' | 'fifo';
  */
 interface CachingOptions<State> {
     /**
-     * Time-to-live in milliseconds
+     * Time-to-live in milliseconds.
      * @default 3600000 (1 hour)
      */
     ttl?: number;
     /**
-     * Maximum number of cache entries
+     * Maximum number of cache entries.
      * @default 100
      */
     maxSize?: number;
     /**
-     * Eviction strategy when cache is full
+     * Eviction strategy when the cache is full.
      * @default 'lru'
      */
     evictionStrategy?: EvictionStrategy;
     /**
-     * Custom cache key generator
-     * @default JSON.stringify
+     * Custom cache key generator.
+     * @default JSON.stringify with String(...) fallback
      */
     keyGenerator?: CacheKeyGenerator<State>;
     /**
-     * Whether to cache errors
+     * Whether to cache thrown `Error` results as `{ error: message }`.
      * @default false
      */
     cacheErrors?: boolean;
     /**
-     * Optional callback when cache hit occurs
+     * Optional callback invoked when a fresh cached value is returned.
      */
     onCacheHit?: (key: string, value: State | Partial<State>) => void;
     /**
-     * Optional callback when cache miss occurs
+     * Optional callback invoked when no cached value is available.
      */
     onCacheMiss?: (key: string) => void;
     /**
-     * Optional callback when cache entry is evicted
+     * Optional callback invoked when a stale cached value is evicted.
      */
     onEviction?: (key: string, value: State | Partial<State>) => void;
 }
+interface SharedCache<State> {
+    withCache: (node: NodeFunction<State>, keyGenerator?: CacheKeyGenerator<State>) => NodeFunction<State>;
+    clear: () => void;
+    size: () => number;
+}
+
+declare function createSharedCache<State>(options?: Omit<CachingOptions<State>, 'keyGenerator'>): SharedCache<State>;
+
+/**
+ * Caching Middleware for LangGraph Nodes
+ *
+ * Provides caching capabilities with TTL, LRU eviction, and custom key generation.
+ */
+
 /**
  * Wraps a node function with caching logic.
  *
  * @example
  * ```typescript
  * const cachedNode = withCache(expensiveNode, {
- *   ttl: 3600000, // 1 hour
+ *   ttl: 3600000,
  *   maxSize: 100,
  *   evictionStrategy: 'lru',
  *   keyGenerator: (state) => state.userId,
- *   onCacheHit: (key) => console.log('Cache hit:', key),
+ *   onCacheHit: (key) => recordCacheHitMetric(key),
  * });
  *
  * graph.addNode('cached', cachedNode);
@@ -2522,14 +2530,6 @@ interface CachingOptions<State> {
  * @returns A wrapped node function with caching
  */
 declare function withCache<State>(node: NodeFunction<State>, options?: CachingOptions<State>): NodeFunction<State>;
-/**
- * Create a cache instance that can be shared across multiple nodes
- */
-declare function createSharedCache<State>(options?: Omit<CachingOptions<State>, 'keyGenerator'>): {
-    withCache: (node: NodeFunction<State>, keyGenerator?: CacheKeyGenerator<State>) => NodeFunction<State>;
-    clear: () => void;
-    size: () => number;
-};
 
 /**
  * Rate limiting strategy

package/dist/index.d.ts

@@ -2445,12 +2445,6 @@ interface TracingOptions {
  */
 declare function withTracing<State>(node: (state: State) => State | Promise<State> | Partial<State> | Promise<Partial<State>>, options: TracingOptions): (state: State) => Promise<State | Partial<State>>;
 
-/**
- * Caching Middleware for LangGraph Nodes
- *
- * Provides caching capabilities with TTL, LRU eviction, and custom key generation.
- */
-
 /**
  * Cache key generator function
  */
@@ -2464,54 +2458,68 @@ type EvictionStrategy = 'lru' | 'lfu' | 'fifo';
  */
 interface CachingOptions<State> {
     /**
-     * Time-to-live in milliseconds
+     * Time-to-live in milliseconds.
      * @default 3600000 (1 hour)
      */
     ttl?: number;
     /**
-     * Maximum number of cache entries
+     * Maximum number of cache entries.
      * @default 100
      */
     maxSize?: number;
     /**
-     * Eviction strategy when cache is full
+     * Eviction strategy when the cache is full.
      * @default 'lru'
      */
     evictionStrategy?: EvictionStrategy;
     /**
-     * Custom cache key generator
-     * @default JSON.stringify
+     * Custom cache key generator.
+     * @default JSON.stringify with String(...) fallback
      */
     keyGenerator?: CacheKeyGenerator<State>;
     /**
-     * Whether to cache errors
+     * Whether to cache thrown `Error` results as `{ error: message }`.
      * @default false
      */
     cacheErrors?: boolean;
     /**
-     * Optional callback when cache hit occurs
+     * Optional callback invoked when a fresh cached value is returned.
      */
     onCacheHit?: (key: string, value: State | Partial<State>) => void;
     /**
-     * Optional callback when cache miss occurs
+     * Optional callback invoked when no cached value is available.
      */
     onCacheMiss?: (key: string) => void;
     /**
-     * Optional callback when cache entry is evicted
+     * Optional callback invoked when a stale cached value is evicted.
      */
     onEviction?: (key: string, value: State | Partial<State>) => void;
 }
+interface SharedCache<State> {
+    withCache: (node: NodeFunction<State>, keyGenerator?: CacheKeyGenerator<State>) => NodeFunction<State>;
+    clear: () => void;
+    size: () => number;
+}
+
+declare function createSharedCache<State>(options?: Omit<CachingOptions<State>, 'keyGenerator'>): SharedCache<State>;
+
+/**
+ * Caching Middleware for LangGraph Nodes
+ *
+ * Provides caching capabilities with TTL, LRU eviction, and custom key generation.
+ */
+
 /**
  * Wraps a node function with caching logic.
  *
  * @example
  * ```typescript
  * const cachedNode = withCache(expensiveNode, {
- *   ttl: 3600000, // 1 hour
+ *   ttl: 3600000,
  *   maxSize: 100,
  *   evictionStrategy: 'lru',
  *   keyGenerator: (state) => state.userId,
- *   onCacheHit: (key) => console.log('Cache hit:', key),
+ *   onCacheHit: (key) => recordCacheHitMetric(key),
  * });
  *
  * graph.addNode('cached', cachedNode);
@@ -2522,14 +2530,6 @@ interface CachingOptions<State> {
  * @returns A wrapped node function with caching
  */
 declare function withCache<State>(node: NodeFunction<State>, options?: CachingOptions<State>): NodeFunction<State>;
-/**
- * Create a cache instance that can be shared across multiple nodes
- */
-declare function createSharedCache<State>(options?: Omit<CachingOptions<State>, 'keyGenerator'>): {
-    withCache: (node: NodeFunction<State>, keyGenerator?: CacheKeyGenerator<State>) => NodeFunction<State>;
-    clear: () => void;
-    size: () => number;
-};
 
 /**
  * Rate limiting strategy

package/dist/index.js

@@ -2713,36 +2713,61 @@ var presets = {
   testing
 };
 
-// src/langgraph/middleware/caching.ts
+// src/langgraph/middleware/caching-options.ts
+function defaultCacheKeyGenerator(state) {
+  try {
+    return JSON.stringify(state);
+  } catch {
+    return String(state);
+  }
+}
+function resolveCachingOptions(options) {
+  return {
+    ttl: options.ttl ?? 36e5,
+    maxSize: options.maxSize ?? 100,
+    evictionStrategy: options.evictionStrategy ?? "lru",
+    keyGenerator: options.keyGenerator ?? defaultCacheKeyGenerator,
+    cacheErrors: options.cacheErrors ?? false,
+    onCacheHit: options.onCacheHit,
+    onCacheMiss: options.onCacheMiss,
+    onEviction: options.onEviction
+  };
+}
+function resolveSharedCacheKeyGenerator(keyGenerator) {
+  return keyGenerator ?? defaultCacheKeyGenerator;
+}
+
+// src/langgraph/middleware/caching-store.ts
 var LRUCache = class {
-  cache = /* @__PURE__ */ new Map();
-  maxSize;
-  evictionStrategy;
   constructor(maxSize, evictionStrategy = "lru") {
     this.maxSize = maxSize;
     this.evictionStrategy = evictionStrategy;
   }
+  cache = /* @__PURE__ */ new Map();
   get(key) {
     const entry = this.cache.get(key);
-    if (!entry) return void 0;
+    if (!entry) {
+      return void 0;
+    }
     entry.hits++;
     entry.lastAccessed = Date.now();
     return entry.value;
   }
+  getEntry(key) {
+    return this.cache.get(key);
+  }
   set(key, value) {
     if (this.cache.size >= this.maxSize && !this.cache.has(key)) {
       this.evict();
     }
+    const now = Date.now();
     this.cache.set(key, {
       value,
-      timestamp: Date.now(),
+      timestamp: now,
       hits: 0,
-      lastAccessed: Date.now()
+      lastAccessed: now
     });
   }
-  has(key) {
-    return this.cache.has(key);
-  }
   delete(key) {
     return this.cache.delete(key);
   }
@@ -2753,138 +2778,99 @@ var LRUCache = class {
     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 (this.cache.size === 0) {
+      return;
     }
-    if (keyToEvict) {
+    const keyToEvict = this.findKeyToEvict();
+    if (keyToEvict !== void 0) {
       this.cache.delete(keyToEvict);
     }
   }
+  findKeyToEvict() {
+    if (this.evictionStrategy === "fifo") {
+      return this.cache.keys().next().value;
+    }
+    let selectedKey;
+    let selectedValue = Infinity;
+    for (const [key, entry] of this.cache.entries()) {
+      const candidateValue = this.evictionStrategy === "lfu" ? entry.hits : entry.lastAccessed;
+      if (candidateValue < selectedValue) {
+        selectedValue = candidateValue;
+        selectedKey = key;
+      }
+    }
+    return selectedKey;
+  }
 };
-function defaultKeyGenerator(state) {
-  try {
-    return JSON.stringify(state);
-  } catch {
-    return String(state);
+
+// src/langgraph/middleware/caching-entry.ts
+function isFreshCacheEntry(entry, ttl) {
+  if (!entry) {
+    return false;
   }
+  return Date.now() - entry.timestamp < ttl;
 }
-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);
+function createCachedErrorResult(error) {
+  return { error: error.message };
+}
+
+// src/langgraph/middleware/caching-wrapper.ts
+function createCachedNode(node, cache2, options, keyGenerator = options.keyGenerator) {
   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);
-        }
-      }
+    const entry = cache2.getEntry(cacheKey);
+    if (cachedValue !== void 0 && isFreshCacheEntry(entry, options.ttl)) {
+      options.onCacheHit?.(cacheKey, cachedValue);
+      return cachedValue;
     }
-    if (onCacheMiss) {
-      onCacheMiss(cacheKey);
+    if (cachedValue !== void 0 && entry) {
+      cache2.delete(cacheKey);
+      options.onEviction?.(cacheKey, cachedValue);
     }
+    options.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);
+      if (options.cacheErrors && error instanceof Error) {
+        cache2.set(cacheKey, createCachedErrorResult(error));
       }
       throw error;
     }
   };
 }
+
+// src/langgraph/middleware/caching-shared.ts
 function createSharedCache(options = {}) {
-  const {
-    ttl = 36e5,
-    maxSize = 100,
-    evictionStrategy = "lru",
-    cacheErrors = false,
-    onCacheHit,
-    onCacheMiss,
-    onEviction
-  } = options;
-  const cache2 = new LRUCache(maxSize, evictionStrategy);
+  const resolvedOptions = resolveCachingOptions(options);
+  const cache2 = new LRUCache(
+    resolvedOptions.maxSize,
+    resolvedOptions.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;
-        }
-      };
-    },
+    withCache: (node, keyGenerator) => createCachedNode(
+      node,
+      cache2,
+      resolvedOptions,
+      resolveSharedCacheKeyGenerator(keyGenerator)
+    ),
     clear: () => cache2.clear(),
     size: () => cache2.size()
   };
 }
 
+// src/langgraph/middleware/caching.ts
+function withCache(node, options = {}) {
+  const resolvedOptions = resolveCachingOptions(options);
+  const cache2 = new LRUCache(
+    resolvedOptions.maxSize,
+    resolvedOptions.evictionStrategy
+  );
+  return createCachedNode(node, cache2, resolvedOptions);
+}
+
 // src/langgraph/middleware/rate-limiting.ts
 var TokenBucket = class {
   constructor(maxTokens, refillRate) {

package/package.json

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