@agentforge/core 0.11.6 → 0.11.8

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,
@@ -121,6 +124,7 @@ __export(index_exports, {
   isHumanRequestInterrupt: () => isHumanRequestInterrupt,
   isMemoryCheckpointer: () => isMemoryCheckpointer,
   isTracingEnabled: () => isTracingEnabled,
+  loadPrompt: () => loadPrompt,
   map: () => map,
   merge: () => merge,
   mergeState: () => mergeState,
@@ -129,8 +133,10 @@ __export(index_exports, {
   presets: () => presets,
   production: () => production,
   reduce: () => reduce,
+  renderTemplate: () => renderTemplate,
   retry: () => retry,
   safeValidateSchemaDescriptions: () => safeValidateSchemaDescriptions,
+  sanitizeValue: () => sanitizeValue,
   sendMessage: () => sendMessage,
   sequential: () => sequential,
   sequentialBuilder: () => sequentialBuilder,
@@ -146,11 +152,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 +2865,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) {
@@ -4350,6 +4933,68 @@ var CircuitBreaker = class {
 function createCircuitBreaker(options) {
   return new CircuitBreaker(options);
 }
+
+// src/prompt-loader/index.ts
+var import_fs = require("fs");
+var import_path = require("path");
+var MAX_VARIABLE_LENGTH = 500;
+function sanitizeValue(value) {
+  if (value === void 0 || value === null) return "";
+  let sanitized = String(value);
+  sanitized = sanitized.replace(/^#+\s*/gm, "");
+  sanitized = sanitized.replace(/[\r\n]+/g, " ");
+  sanitized = sanitized.trim().replace(/\s+/g, " ");
+  if (sanitized.length > MAX_VARIABLE_LENGTH) {
+    sanitized = sanitized.substring(0, MAX_VARIABLE_LENGTH) + "...";
+  }
+  return sanitized;
+}
+function renderTemplate(template, options) {
+  let rawVariables;
+  let sanitizedVariables;
+  if ("trustedVariables" in options || "untrustedVariables" in options) {
+    const opts = options;
+    rawVariables = {
+      ...opts.trustedVariables,
+      ...opts.untrustedVariables
+    };
+    const sanitizedUntrusted = {};
+    if (opts.untrustedVariables) {
+      for (const [key, value] of Object.entries(opts.untrustedVariables)) {
+        sanitizedUntrusted[key] = sanitizeValue(value);
+      }
+    }
+    sanitizedVariables = {
+      ...opts.trustedVariables,
+      ...sanitizedUntrusted
+    };
+  } else {
+    rawVariables = options;
+    sanitizedVariables = options;
+  }
+  let result = template;
+  result = result.replace(/\{\{#if\s+(\w+)\}\}([\s\S]*?)\{\{\/if\}\}/g, (_, varName, content) => {
+    return rawVariables[varName] ? content : "";
+  });
+  result = result.replace(/\{\{(\w+)\}\}/g, (_, varName) => {
+    const value = sanitizedVariables[varName];
+    if (value === void 0 || value === null) return "";
+    return String(value);
+  });
+  return result;
+}
+function loadPrompt(promptName, options = {}, promptsDir) {
+  const baseDir = promptsDir || (0, import_path.join)(process.cwd(), "prompts");
+  const promptPath = (0, import_path.join)(baseDir, `${promptName}.md`);
+  try {
+    const template = (0, import_fs.readFileSync)(promptPath, "utf-8");
+    return renderTemplate(template, options);
+  } catch (error) {
+    throw new Error(
+      `Failed to load prompt "${promptName}" from ${promptPath}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AgentError,
@@ -4413,6 +5058,9 @@ function createCircuitBreaker(options) {
   createProgressTracker,
   createSSEFormatter,
   createSequentialWorkflow,
+  createSharedCache,
+  createSharedConcurrencyController,
+  createSharedRateLimiter,
   createSqliteCheckpointer,
   createStateAnnotation,
   createSubgraph,
@@ -4443,6 +5091,7 @@ function createCircuitBreaker(options) {
   isHumanRequestInterrupt,
   isMemoryCheckpointer,
   isTracingEnabled,
+  loadPrompt,
   map,
   merge,
   mergeState,
@@ -4451,8 +5100,10 @@ function createCircuitBreaker(options) {
   presets,
   production,
   reduce,
+  renderTemplate,
   retry,
   safeValidateSchemaDescriptions,
+  sanitizeValue,
   sendMessage,
   sequential,
   sequentialBuilder,
@@ -4468,9 +5119,14 @@ function createCircuitBreaker(options) {
   validateTool,
   validateToolMetadata,
   validateToolName,
+  withCache,
+  withConcurrency,
   withErrorHandler,
+  withLogging,
   withMetrics,
+  withRateLimit,
   withRetry,
   withTimeout,
-  withTracing
+  withTracing,
+  withValidation
 });