@agentforge/core 0.9.0 → 0.9.1

package/dist/index.js

@@ -2134,7 +2134,86 @@ function composeGraphs(parentGraph, subgraph, options) {
   return parentGraph;
 }
 
-// src/langgraph/patterns/retry.ts
+// src/langgraph/middleware/compose.ts
+function compose(...middleware) {
+  return (node) => {
+    return middleware.reduceRight(
+      (wrappedNode, mw) => mw(wrappedNode),
+      node
+    );
+  };
+}
+function composeWithOptions(options, ...middleware) {
+  const { reverse = false, name, catchErrors = true } = options;
+  return (node) => {
+    const orderedMiddleware = reverse ? [...middleware].reverse() : middleware;
+    let wrappedNode = orderedMiddleware.reduceRight(
+      (wrappedNode2, mw) => mw(wrappedNode2),
+      node
+    );
+    if (catchErrors) {
+      const originalNode = wrappedNode;
+      wrappedNode = async (state) => {
+        try {
+          return await Promise.resolve(originalNode(state));
+        } catch (error) {
+          const enhancedError = error instanceof Error ? error : new Error(String(error));
+          if (name) {
+            enhancedError.message = `[${name}] ${enhancedError.message}`;
+          }
+          throw enhancedError;
+        }
+      };
+    }
+    return wrappedNode;
+  };
+}
+var MiddlewareChain = class {
+  middleware = [];
+  options = {};
+  /**
+   * Add middleware to the chain.
+   */
+  use(middleware) {
+    this.middleware.push(middleware);
+    return this;
+  }
+  /**
+   * Set composition options.
+   */
+  withOptions(options) {
+    this.options = { ...this.options, ...options };
+    return this;
+  }
+  /**
+   * Build the middleware chain and apply it to a node.
+   */
+  build(node) {
+    if (this.middleware.length === 0) {
+      return node;
+    }
+    return composeWithOptions(this.options, ...this.middleware)(node);
+  }
+  /**
+   * Get the number of middleware in the chain.
+   */
+  get length() {
+    return this.middleware.length;
+  }
+};
+function chain() {
+  return new MiddlewareChain();
+}
+function createMiddlewareContext() {
+  return {
+    executionId: `exec_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+    startTime: Date.now(),
+    data: {},
+    middlewareStack: []
+  };
+}
+
+// src/langgraph/middleware/retry.ts
 function calculateDelay(attempt, strategy, initialDelay, maxDelay) {
   let delay;
   switch (strategy) {
@@ -2186,7 +2265,7 @@ function withRetry(node, options = {}) {
   };
 }
 
-// src/langgraph/patterns/error-handler.ts
+// src/langgraph/middleware/error-handler.ts
 function withErrorHandler(node, options) {
   const { onError, logError, rethrow = false } = options;
   return async (state) => {
@@ -2206,7 +2285,7 @@ function withErrorHandler(node, options) {
   };
 }
 
-// src/langgraph/patterns/timeout.ts
+// src/langgraph/middleware/timeout.ts
 var TimeoutError = class extends Error {
   constructor(timeout2) {
     super(`Node execution timed out after ${timeout2}ms`);
@@ -2238,150 +2317,6 @@ function withTimeout(node, options) {
   };
 }
 
-// src/langgraph/persistence/checkpointer.ts
-import { MemorySaver } from "@langchain/langgraph";
-function createMemoryCheckpointer(options) {
-  return new MemorySaver();
-}
-async function createSqliteCheckpointer(options = {}) {
-  const { path = ":memory:", autoMigrate = true } = options;
-  try {
-    const { SqliteSaver } = await import("@langchain/langgraph-checkpoint-sqlite");
-    const checkpointer = SqliteSaver.fromConnString(path);
-    if (autoMigrate) {
-      await checkpointer.setup();
-    }
-    return checkpointer;
-  } catch (error) {
-    if (error instanceof Error && error.message.includes("Cannot find module")) {
-      throw new Error(
-        "SQLite checkpointer requires @langchain/langgraph-checkpoint-sqlite to be installed. Install it with: npm install @langchain/langgraph-checkpoint-sqlite"
-      );
-    }
-    throw error;
-  }
-}
-function isMemoryCheckpointer(checkpointer) {
-  return checkpointer instanceof MemorySaver;
-}
-
-// src/langgraph/persistence/thread.ts
-import { randomUUID } from "crypto";
-function generateThreadId(seed) {
-  if (seed && seed.length > 0) {
-    const hash = Buffer.from(seed).toString("base64").replace(/[^a-zA-Z0-9]/g, "");
-    return `thread-${hash}`;
-  }
-  return randomUUID();
-}
-function createThreadConfig(config = {}) {
-  const { threadId = generateThreadId(), checkpointId, checkpointNamespace, metadata } = config;
-  const runnableConfig = {
-    configurable: {
-      thread_id: threadId
-    }
-  };
-  if (checkpointId) {
-    runnableConfig.configurable.checkpoint_id = checkpointId;
-  }
-  if (checkpointNamespace) {
-    runnableConfig.configurable.checkpoint_ns = checkpointNamespace;
-  }
-  if (metadata) {
-    runnableConfig.metadata = metadata;
-  }
-  return runnableConfig;
-}
-function createConversationConfig(config) {
-  const { userId, sessionId, metadata = {} } = config;
-  const threadId = sessionId ? generateThreadId(`${userId}-${sessionId}`) : generateThreadId(userId);
-  return createThreadConfig({
-    threadId,
-    metadata: {
-      ...metadata,
-      userId,
-      sessionId
-    }
-  });
-}
-
-// src/langgraph/persistence/utils.ts
-async function getCheckpointHistory(checkpointer, options) {
-  const { threadId, limit = 10, before } = options;
-  const config = {
-    configurable: {
-      thread_id: threadId
-    }
-  };
-  if (before) {
-    config.configurable.checkpoint_id = before;
-  }
-  const checkpoints = [];
-  for await (const checkpoint of checkpointer.list(config, { limit })) {
-    checkpoints.push(checkpoint);
-  }
-  return checkpoints;
-}
-async function getLatestCheckpoint(checkpointer, options) {
-  const { threadId } = options;
-  const config = {
-    configurable: {
-      thread_id: threadId
-    }
-  };
-  const tuple = await checkpointer.getTuple(config);
-  return tuple || null;
-}
-async function clearThread(checkpointer, options) {
-  const { threadId } = options;
-  const checkpoints = await getCheckpointHistory(checkpointer, {
-    threadId,
-    limit: 1e3
-    // Get all checkpoints
-  });
-  if (checkpoints.length > 0) {
-    throw new Error(
-      "Clearing threads is not supported by the current checkpointer implementation. Consider using a new thread ID instead."
-    );
-  }
-}
-
-// src/langgraph/observability/langsmith.ts
-var globalConfig = null;
-function configureLangSmith(config) {
-  globalConfig = config;
-  if (config.apiKey) {
-    process.env.LANGSMITH_API_KEY = config.apiKey;
-  }
-  if (config.projectName) {
-    process.env.LANGSMITH_PROJECT = config.projectName;
-  }
-  if (config.tracingEnabled !== void 0) {
-    process.env.LANGSMITH_TRACING = config.tracingEnabled ? "true" : "false";
-  } else if (config.apiKey) {
-    process.env.LANGSMITH_TRACING = "true";
-  }
-  if (config.endpoint) {
-    process.env.LANGSMITH_ENDPOINT = config.endpoint;
-  }
-}
-function getLangSmithConfig() {
-  return globalConfig;
-}
-function isTracingEnabled() {
-  return process.env.LANGSMITH_TRACING === "true";
-}
-function withTracing(node, options) {
-  const { name, metadata, tags, runName } = options;
-  return async (state) => {
-    if (isTracingEnabled()) {
-      const result = await Promise.resolve(node(state));
-      return result;
-    }
-    return await Promise.resolve(node(state));
-  };
-}
-
 // src/langgraph/observability/metrics.ts
 var MetricType = /* @__PURE__ */ ((MetricType2) => {
   MetricType2["COUNTER"] = "counter";
@@ -2490,189 +2425,39 @@ function withMetrics(node, options) {
   };
 }
 
-// src/langgraph/observability/errors.ts
-var AgentError = class _AgentError extends Error {
-  code;
-  node;
-  state;
-  metadata;
-  cause;
-  timestamp;
-  constructor(message, context = {}) {
-    super(message);
-    this.name = "AgentError";
-    this.code = context.code;
-    this.node = context.node;
-    this.state = context.state;
-    this.metadata = context.metadata;
-    this.cause = context.cause;
-    this.timestamp = Date.now();
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, _AgentError);
-    }
+// src/langgraph/observability/langsmith.ts
+var globalConfig = null;
+function configureLangSmith(config) {
+  globalConfig = config;
+  if (config.apiKey) {
+    process.env.LANGSMITH_API_KEY = config.apiKey;
   }
-  /**
-   * Convert error to JSON for logging/reporting
-   */
-  toJSON() {
-    return {
-      name: this.name,
-      message: this.message,
-      code: this.code,
-      node: this.node,
-      state: this.state,
-      metadata: this.metadata,
-      timestamp: this.timestamp,
-      stack: this.stack,
-      cause: this.cause ? {
-        name: this.cause.name,
-        message: this.cause.message,
-        stack: this.cause.stack
-      } : void 0
-    };
-  }
-  /**
-   * Get a human-readable string representation
-   */
-  toString() {
-    const parts = [`${this.name}: ${this.message}`];
-    if (this.code) {
-      parts.push(`Code: ${this.code}`);
-    }
-    if (this.node) {
-      parts.push(`Node: ${this.node}`);
-    }
-    if (this.cause) {
-      parts.push(`Caused by: ${this.cause.message}`);
-    }
-    return parts.join("\n");
-  }
-};
-var ErrorReporterImpl = class {
-  options;
-  constructor(options) {
-    this.options = {
-      onError: options.onError,
-      includeStackTrace: options.includeStackTrace ?? true,
-      includeState: options.includeState ?? false,
-      rethrow: options.rethrow ?? true
-    };
-  }
-  wrap(node, nodeName) {
-    return async (state) => {
-      try {
-        return await Promise.resolve(node(state));
-      } catch (error) {
-        const agentError = this.toAgentError(error, {
-          node: nodeName,
-          state: this.options.includeState ? state : void 0
-        });
-        await this.report(agentError);
-        if (this.options.rethrow) {
-          throw agentError;
-        }
-        return state;
-      }
-    };
+  if (config.projectName) {
+    process.env.LANGSMITH_PROJECT = config.projectName;
   }
-  async report(error, context) {
-    const agentError = this.toAgentError(error, context);
-    try {
-      await Promise.resolve(this.options.onError(agentError));
-    } catch (reportError) {
-      console.error("Error reporting failed:", reportError);
-    }
+  if (config.tracingEnabled !== void 0) {
+    process.env.LANGSMITH_TRACING = config.tracingEnabled ? "true" : "false";
+  } else if (config.apiKey) {
+    process.env.LANGSMITH_TRACING = "true";
   }
-  toAgentError(error, context) {
-    if (error instanceof AgentError) {
-      return error;
-    }
-    return new AgentError(error.message, {
-      ...context,
-      cause: error
-    });
+  if (config.endpoint) {
+    process.env.LANGSMITH_ENDPOINT = config.endpoint;
   }
-};
-function createErrorReporter(options) {
-  return new ErrorReporterImpl(options);
 }
-
-// src/langgraph/middleware/compose.ts
-function compose(...middleware) {
-  return (node) => {
-    return middleware.reduceRight(
-      (wrappedNode, mw) => mw(wrappedNode),
-      node
-    );
-  };
+function getLangSmithConfig() {
+  return globalConfig;
 }
-function composeWithOptions(options, ...middleware) {
-  const { reverse = false, name, catchErrors = true } = options;
-  return (node) => {
-    const orderedMiddleware = reverse ? [...middleware].reverse() : middleware;
-    let wrappedNode = orderedMiddleware.reduceRight(
-      (wrappedNode2, mw) => mw(wrappedNode2),
-      node
-    );
-    if (catchErrors) {
-      const originalNode = wrappedNode;
-      wrappedNode = async (state) => {
-        try {
-          return await Promise.resolve(originalNode(state));
-        } catch (error) {
-          const enhancedError = error instanceof Error ? error : new Error(String(error));
-          if (name) {
-            enhancedError.message = `[${name}] ${enhancedError.message}`;
-          }
-          throw enhancedError;
-        }
-      };
-    }
-    return wrappedNode;
-  };
+function isTracingEnabled() {
+  return process.env.LANGSMITH_TRACING === "true";
 }
-var MiddlewareChain = class {
-  middleware = [];
-  options = {};
-  /**
-   * Add middleware to the chain.
-   */
-  use(middleware) {
-    this.middleware.push(middleware);
-    return this;
-  }
-  /**
-   * Set composition options.
-   */
-  withOptions(options) {
-    this.options = { ...this.options, ...options };
-    return this;
-  }
-  /**
-   * Build the middleware chain and apply it to a node.
-   */
-  build(node) {
-    if (this.middleware.length === 0) {
-      return node;
+function withTracing(node, options) {
+  const { name, metadata, tags, runName } = options;
+  return async (state) => {
+    if (isTracingEnabled()) {
+      const result = await Promise.resolve(node(state));
+      return result;
     }
-    return composeWithOptions(this.options, ...this.middleware)(node);
-  }
-  /**
-   * Get the number of middleware in the chain.
-   */
-  get length() {
-    return this.middleware.length;
-  }
-};
-function chain() {
-  return new MiddlewareChain();
-}
-function createMiddlewareContext() {
-  return {
-    executionId: `exec_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
-    startTime: Date.now(),
-    data: {},
-    middlewareStack: []
+    return await Promise.resolve(node(state));
   };
 }
 
@@ -2874,6 +2659,221 @@ var presets = {
   testing
 };
 
+// src/langgraph/persistence/checkpointer.ts
+import { MemorySaver } from "@langchain/langgraph";
+function createMemoryCheckpointer(options) {
+  return new MemorySaver();
+}
+async function createSqliteCheckpointer(options = {}) {
+  const { path = ":memory:", autoMigrate = true } = options;
+  try {
+    const { SqliteSaver } = await import("@langchain/langgraph-checkpoint-sqlite");
+    const checkpointer = SqliteSaver.fromConnString(path);
+    if (autoMigrate) {
+      await checkpointer.setup();
+    }
+    return checkpointer;
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("Cannot find module")) {
+      throw new Error(
+        "SQLite checkpointer requires @langchain/langgraph-checkpoint-sqlite to be installed. Install it with: npm install @langchain/langgraph-checkpoint-sqlite"
+      );
+    }
+    throw error;
+  }
+}
+function isMemoryCheckpointer(checkpointer) {
+  return checkpointer instanceof MemorySaver;
+}
+
+// src/langgraph/persistence/thread.ts
+import { randomUUID } from "crypto";
+function generateThreadId(seed) {
+  if (seed && seed.length > 0) {
+    const hash = Buffer.from(seed).toString("base64").replace(/[^a-zA-Z0-9]/g, "");
+    return `thread-${hash}`;
+  }
+  return randomUUID();
+}
+function createThreadConfig(config = {}) {
+  const { threadId = generateThreadId(), checkpointId, checkpointNamespace, metadata } = config;
+  const runnableConfig = {
+    configurable: {
+      thread_id: threadId
+    }
+  };
+  if (checkpointId) {
+    runnableConfig.configurable.checkpoint_id = checkpointId;
+  }
+  if (checkpointNamespace) {
+    runnableConfig.configurable.checkpoint_ns = checkpointNamespace;
+  }
+  if (metadata) {
+    runnableConfig.metadata = metadata;
+  }
+  return runnableConfig;
+}
+function createConversationConfig(config) {
+  const { userId, sessionId, metadata = {} } = config;
+  const threadId = sessionId ? generateThreadId(`${userId}-${sessionId}`) : generateThreadId(userId);
+  return createThreadConfig({
+    threadId,
+    metadata: {
+      ...metadata,
+      userId,
+      sessionId
+    }
+  });
+}
+
+// src/langgraph/persistence/utils.ts
+async function getCheckpointHistory(checkpointer, options) {
+  const { threadId, limit = 10, before } = options;
+  const config = {
+    configurable: {
+      thread_id: threadId
+    }
+  };
+  if (before) {
+    config.configurable.checkpoint_id = before;
+  }
+  const checkpoints = [];
+  for await (const checkpoint of checkpointer.list(config, { limit })) {
+    checkpoints.push(checkpoint);
+  }
+  return checkpoints;
+}
+async function getLatestCheckpoint(checkpointer, options) {
+  const { threadId } = options;
+  const config = {
+    configurable: {
+      thread_id: threadId
+    }
+  };
+  const tuple = await checkpointer.getTuple(config);
+  return tuple || null;
+}
+async function clearThread(checkpointer, options) {
+  const { threadId } = options;
+  const checkpoints = await getCheckpointHistory(checkpointer, {
+    threadId,
+    limit: 1e3
+    // Get all checkpoints
+  });
+  if (checkpoints.length > 0) {
+    throw new Error(
+      "Clearing threads is not supported by the current checkpointer implementation. Consider using a new thread ID instead."
+    );
+  }
+}
+
+// src/langgraph/observability/errors.ts
+var AgentError = class _AgentError extends Error {
+  code;
+  node;
+  state;
+  metadata;
+  cause;
+  timestamp;
+  constructor(message, context = {}) {
+    super(message);
+    this.name = "AgentError";
+    this.code = context.code;
+    this.node = context.node;
+    this.state = context.state;
+    this.metadata = context.metadata;
+    this.cause = context.cause;
+    this.timestamp = Date.now();
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _AgentError);
+    }
+  }
+  /**
+   * Convert error to JSON for logging/reporting
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      node: this.node,
+      state: this.state,
+      metadata: this.metadata,
+      timestamp: this.timestamp,
+      stack: this.stack,
+      cause: this.cause ? {
+        name: this.cause.name,
+        message: this.cause.message,
+        stack: this.cause.stack
+      } : void 0
+    };
+  }
+  /**
+   * Get a human-readable string representation
+   */
+  toString() {
+    const parts = [`${this.name}: ${this.message}`];
+    if (this.code) {
+      parts.push(`Code: ${this.code}`);
+    }
+    if (this.node) {
+      parts.push(`Node: ${this.node}`);
+    }
+    if (this.cause) {
+      parts.push(`Caused by: ${this.cause.message}`);
+    }
+    return parts.join("\n");
+  }
+};
+var ErrorReporterImpl = class {
+  options;
+  constructor(options) {
+    this.options = {
+      onError: options.onError,
+      includeStackTrace: options.includeStackTrace ?? true,
+      includeState: options.includeState ?? false,
+      rethrow: options.rethrow ?? true
+    };
+  }
+  wrap(node, nodeName) {
+    return async (state) => {
+      try {
+        return await Promise.resolve(node(state));
+      } catch (error) {
+        const agentError = this.toAgentError(error, {
+          node: nodeName,
+          state: this.options.includeState ? state : void 0
+        });
+        await this.report(agentError);
+        if (this.options.rethrow) {
+          throw agentError;
+        }
+        return state;
+      }
+    };
+  }
+  async report(error, context) {
+    const agentError = this.toAgentError(error, context);
+    try {
+      await Promise.resolve(this.options.onError(agentError));
+    } catch (reportError) {
+      console.error("Error reporting failed:", reportError);
+    }
+  }
+  toAgentError(error, context) {
+    if (error instanceof AgentError) {
+      return error;
+    }
+    return new AgentError(error.message, {
+      ...context,
+      cause: error
+    });
+  }
+};
+function createErrorReporter(options) {
+  return new ErrorReporterImpl(options);
+}
+
 // src/langgraph/interrupts/utils.ts
 function createHumanRequestInterrupt(request) {
   return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentforge/core",
-  "version": "0.9.0",
+  "version": "0.9.1",
   "description": "Core abstractions for AgentForge - production-ready deep agents framework",
   "type": "module",
   "main": "./dist/index.cjs",