@agentforge/core 0.16.50 → 0.16.52

package/dist/index.cjs

@@ -2107,8 +2107,10 @@ function createToolSimulator(config) {
   };
 }
 
-// src/langgraph/state.ts
+// src/langgraph/state-annotation.ts
 var import_langgraph = require("@langchain/langgraph");
+
+// src/langgraph/state-shared.ts
 function entriesOf(value) {
   return Object.entries(value);
 }
@@ -2127,6 +2129,8 @@ function setStateValue(target, key, value) {
 function setStateDefinitionValue(target, key, value) {
   target[key] = value;
 }
+
+// src/langgraph/state-annotation.ts
 function createChannel(channelConfig) {
   if (channelConfig.reducer) {
     return (0, import_langgraph.Annotation)({
@@ -2153,6 +2157,8 @@ function createStateAnnotation(config) {
   }
   return import_langgraph.Annotation.Root(stateDefinition);
 }
+
+// src/langgraph/state-validation.ts
 function validateState(state, config) {
   const validated = {};
   for (const [key, channelConfig] of entriesOf(config)) {
@@ -2170,6 +2176,8 @@ function validateState(state, config) {
   }
   return validated;
 }
+
+// src/langgraph/state-merge.ts
 function mergeState(currentState, update, config) {
   const merged = { ...currentState };
   for (const key of keysOf(update)) {
@@ -2438,110 +2446,6 @@ function createMiddlewareContext() {
   };
 }
 
-// src/langgraph/middleware/retry.ts
-function calculateDelay(attempt, strategy, initialDelay, maxDelay) {
-  let delay;
-  switch (strategy) {
-    case "constant":
-      delay = initialDelay;
-      break;
-    case "linear":
-      delay = initialDelay * attempt;
-      break;
-    case "exponential":
-      delay = initialDelay * Math.pow(2, attempt - 1);
-      break;
-  }
-  return Math.min(delay, maxDelay);
-}
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function withRetry(node, options = {}) {
-  const {
-    maxAttempts = 3,
-    backoff = "exponential",
-    initialDelay = 1e3,
-    maxDelay = 3e4,
-    onRetry,
-    shouldRetry = () => true
-  } = options;
-  return async (state) => {
-    let lastError;
-    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-      try {
-        return await Promise.resolve(node(state));
-      } catch (error) {
-        lastError = error instanceof Error ? error : new Error(String(error));
-        if (!shouldRetry(lastError)) {
-          throw lastError;
-        }
-        if (attempt === maxAttempts) {
-          throw lastError;
-        }
-        if (onRetry) {
-          onRetry(lastError, attempt);
-        }
-        const delay = calculateDelay(attempt, backoff, initialDelay, maxDelay);
-        await sleep(delay);
-      }
-    }
-    throw lastError || new Error("Retry failed");
-  };
-}
-
-// src/langgraph/middleware/error-handler.ts
-function withErrorHandler(node, options) {
-  const { onError, logError, rethrow = false } = options;
-  return async (state) => {
-    try {
-      return await Promise.resolve(node(state));
-    } catch (error) {
-      const err = error instanceof Error ? error : new Error(String(error));
-      if (logError) {
-        logError(err, state);
-      }
-      const result = await Promise.resolve(onError(err, state));
-      if (rethrow) {
-        throw err;
-      }
-      return result;
-    }
-  };
-}
-
-// src/langgraph/middleware/timeout.ts
-var TimeoutError = class extends Error {
-  constructor(timeout2) {
-    super(`Node execution timed out after ${timeout2}ms`);
-    this.name = "TimeoutError";
-  }
-};
-function withTimeout(node, options) {
-  const { timeout: timeout2, onTimeout, logTimeout, throwOnTimeout = false } = options;
-  return async (state) => {
-    const timeoutPromise = new Promise((_, reject) => {
-      setTimeout(() => {
-        reject(new TimeoutError(timeout2));
-      }, timeout2);
-    });
-    try {
-      return await Promise.race([Promise.resolve(node(state)), timeoutPromise]);
-    } catch (error) {
-      if (error instanceof TimeoutError) {
-        if (logTimeout) {
-          logTimeout(state);
-        }
-        if (throwOnTimeout) {
-          throw error;
-        }
-        return await Promise.resolve(onTimeout(state));
-      }
-      throw error;
-    }
-  };
-}
-
 // src/langgraph/observability/metrics.ts
 var MetricType = /* @__PURE__ */ ((MetricType2) => {
   MetricType2["COUNTER"] = "counter";
@@ -2686,6 +2590,26 @@ function withTracing(node, options) {
   };
 }
 
+// src/langgraph/middleware/error-handler.ts
+function withErrorHandler(node, options) {
+  const { onError, logError, rethrow = false } = options;
+  return async (state) => {
+    try {
+      return await Promise.resolve(node(state));
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      if (logError) {
+        logError(err, state);
+      }
+      const result = await Promise.resolve(onError(err, state));
+      if (rethrow) {
+        throw err;
+      }
+      return result;
+    }
+  };
+}
+
 // src/langgraph/middleware/logging.ts
 var withLogging = (options) => {
   const {
@@ -2745,7 +2669,91 @@ var withLogging = (options) => {
   };
 };
 
-// src/langgraph/middleware/presets.ts
+// src/langgraph/middleware/retry.ts
+function calculateDelay(attempt, strategy, initialDelay, maxDelay) {
+  let delay;
+  switch (strategy) {
+    case "constant":
+      delay = initialDelay;
+      break;
+    case "linear":
+      delay = initialDelay * attempt;
+      break;
+    case "exponential":
+      delay = initialDelay * Math.pow(2, attempt - 1);
+      break;
+  }
+  return Math.min(delay, maxDelay);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function withRetry(node, options = {}) {
+  const {
+    maxAttempts = 3,
+    backoff = "exponential",
+    initialDelay = 1e3,
+    maxDelay = 3e4,
+    onRetry,
+    shouldRetry = () => true
+  } = options;
+  return async (state) => {
+    let lastError;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      try {
+        return await Promise.resolve(node(state));
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        if (!shouldRetry(lastError)) {
+          throw lastError;
+        }
+        if (attempt === maxAttempts) {
+          throw lastError;
+        }
+        if (onRetry) {
+          onRetry(lastError, attempt);
+        }
+        const delay = calculateDelay(attempt, backoff, initialDelay, maxDelay);
+        await sleep(delay);
+      }
+    }
+    throw lastError || new Error("Retry failed");
+  };
+}
+
+// src/langgraph/middleware/timeout.ts
+var TimeoutError = class extends Error {
+  constructor(timeout2) {
+    super(`Node execution timed out after ${timeout2}ms`);
+    this.name = "TimeoutError";
+  }
+};
+function withTimeout(node, options) {
+  const { timeout: timeout2, onTimeout, logTimeout, throwOnTimeout = false } = options;
+  return async (state) => {
+    const timeoutPromise = new Promise((_, reject) => {
+      setTimeout(() => {
+        reject(new TimeoutError(timeout2));
+      }, timeout2);
+    });
+    try {
+      return await Promise.race([Promise.resolve(node(state)), timeoutPromise]);
+    } catch (error) {
+      if (error instanceof TimeoutError) {
+        if (logTimeout) {
+          logTimeout(state);
+        }
+        if (throwOnTimeout) {
+          throw error;
+        }
+        return await Promise.resolve(onTimeout(state));
+      }
+      throw error;
+    }
+  };
+}
+
+// src/langgraph/middleware/preset-adapters.ts
 function withRetry2(options) {
   return (node) => withRetry(node, options);
 }
@@ -2764,6 +2772,8 @@ function withTracing2(options) {
 function withLogging2(options) {
   return (node) => withLogging(options)(node);
 }
+
+// src/langgraph/middleware/preset-production.ts
 function production(node, options) {
   const {
     nodeName,
@@ -2776,27 +2786,20 @@ function production(node, options) {
     errorOptions = {}
   } = options;
   const actualLogger = logger6 || createLogger(nodeName, { level: "info" /* INFO */ });
-  const middleware = [];
-  middleware.push(
+  const middleware = [
     withLogging2({
       logger: actualLogger,
       name: nodeName,
       logInput: false,
-      // Don't log input in production by default
       logOutput: false,
-      // Don't log output in production by default
       logDuration: true,
       logErrors: true
-    })
-  );
-  middleware.push(
+    }),
     withErrorHandler2({
-      onError: (error, state) => {
-        return state;
-      },
+      onError: (_error, state) => state,
       ...errorOptions
     })
-  );
+  ];
   if (enableRetry) {
     middleware.push(
       withRetry2({
@@ -2810,19 +2813,18 @@ function production(node, options) {
   middleware.push(
     withTimeout2({
       timeout: timeout2,
-      onTimeout: (state) => {
-        return state;
-      }
+      onTimeout: (state) => state
     })
   );
   if (enableMetrics) {
+    const metricsOptions = {
+      name: nodeName,
+      trackDuration: true,
+      trackErrors: true,
+      trackInvocations: true
+    };
     middleware.push(
-      withMetrics2({
-        name: nodeName,
-        trackDuration: true,
-        trackErrors: true,
-        trackInvocations: true
-      })
+      withMetrics2(metricsOptions)
     );
   }
   if (enableTracing) {
@@ -2835,12 +2837,10 @@ function production(node, options) {
   }
   return compose(...middleware)(node);
 }
+
+// src/langgraph/middleware/preset-development.ts
 function development(node, options) {
-  const {
-    nodeName,
-    verbose = true,
-    logger: logger6
-  } = options;
+  const { nodeName, verbose = true, logger: logger6 } = options;
   const actualLogger = logger6 || createLogger(nodeName, { level: "debug" /* DEBUG */ });
   return withLogging2({
     logger: actualLogger,
@@ -2851,9 +2851,10 @@ function development(node, options) {
     logErrors: true
   })(node);
 }
+
+// src/langgraph/middleware/preset-testing.ts
 function testing(node, options) {
   const {
-    nodeName,
     mockResponse,
     simulateError,
     delay = 0,
@@ -2875,9 +2876,12 @@ function testing(node, options) {
     }
     return await Promise.resolve(node(state));
   };
-  wrappedNode.invocations = invocations;
-  return wrappedNode;
+  const testingNode = wrappedNode;
+  testingNode.invocations = invocations;
+  return testingNode;
 }
+
+// src/langgraph/middleware/preset-collection.ts
 var presets = {
   production,
   development,