@ai.ntellect/core 1.0.0 → 1.1.0

package/execution/controller.ts

@@ -0,0 +1,84 @@
+import { ZodSchema } from "zod";
+import { GraphExecutionResult } from "../types";
+import { GraphFlow } from "./index";
+
+/**
+ * Controller class for managing the execution of graph flows
+ * Handles both sequential and parallel execution of multiple graphs
+ */
+export class GraphController {
+  /**
+   * Executes multiple graphs sequentially
+   * @param graphs - Array of GraphFlow instances to execute
+   * @param startNodes - Array of starting node identifiers for each graph
+   * @param contexts - Optional array of contexts for each graph
+   * @returns Map containing results of each graph execution, keyed by graph name and index
+   * @template T - Zod schema type for graph context validation
+   */
+  static async executeSequential<T extends ZodSchema>(
+    graphs: GraphFlow<T>[],
+    startNodes: string[],
+    contexts?: Partial<any>[]
+  ): Promise<GraphExecutionResult<T>[]> {
+    const results: GraphExecutionResult<T>[] = [];
+
+    for (let i = 0; i < graphs.length; i++) {
+      const context = await graphs[i].execute(startNodes[i], contexts?.[i]);
+      results.push({
+        graphName: graphs[i].name,
+        nodeName: startNodes[i],
+        context,
+      });
+    }
+
+    return results;
+  }
+
+  private static async executeGraph<T extends ZodSchema>(
+    graph: GraphFlow<T>,
+    startNode: string,
+    context?: Partial<any>
+  ): Promise<GraphExecutionResult<T>> {
+    try {
+      const result = await graph.execute(startNode, context);
+      return {
+        graphName: graph.name,
+        nodeName: startNode,
+        context: result,
+      };
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  /**
+   * Executes multiple graphs in parallel with optional concurrency control
+   * @param graphs - Array of GraphFlow instances to execute
+   * @param startNodes - Array of starting node identifiers for each graph
+   * @param concurrency - Optional limit on number of concurrent graph executions
+   * @param contexts - Optional array of contexts for each graph
+   * @returns Map containing results of each graph execution, keyed by graph name
+   * @template T - Zod schema type for graph context validation
+   */
+  static async executeParallel<T extends ZodSchema>(
+    graphs: GraphFlow<T>[],
+    startNodes: string[],
+    concurrency: number,
+    contexts?: Partial<any>[]
+  ): Promise<GraphExecutionResult<T>[]> {
+    const results: GraphExecutionResult<T>[] = [];
+
+    for (let i = 0; i < graphs.length; i += concurrency) {
+      const batch = graphs.slice(i, i + concurrency);
+      const batchResults = await Promise.all(
+        batch.map((graph, idx) => {
+          const context = contexts?.[i + idx];
+          return this.executeGraph(graph, startNodes[i + idx], context);
+        })
+      );
+      results.push(...batchResults);
+    }
+
+    return results;
+  }
+}

package/execution/event-manager.ts

@@ -0,0 +1,331 @@
+import { ZodSchema } from "zod";
+import { IEventEmitter } from "../interfaces";
+import {
+  EventConfig,
+  GraphContext,
+  GraphEvent,
+  GraphNodeConfig,
+} from "../types";
+import { GraphNode } from "./node";
+
+export class GraphEventManager<T extends ZodSchema> {
+  private context: GraphContext<T>;
+  private name: string;
+  private graphEvents?: string[];
+  private entryNode?: string;
+  private globalErrorHandler?: (error: Error, context: GraphContext<T>) => void;
+  private lastEvents = new Map<string, any>();
+
+  constructor(
+    private eventEmitter: IEventEmitter,
+    private nodes: Map<string, GraphNodeConfig<T, any>>,
+    name: string,
+    context: GraphContext<T>,
+    graphEvents?: string[],
+    entryNode?: string,
+    globalErrorHandler?: (error: Error, context: GraphContext<T>) => void,
+    private nodeExecutor?: GraphNode<T>
+  ) {
+    this.name = name;
+    this.context = context;
+    this.graphEvents = graphEvents;
+    this.entryNode = entryNode;
+    this.globalErrorHandler = globalErrorHandler;
+  }
+
+  /** @deprecated No-op — event streams are no longer managed here */
+  public setupEventStreams(): void {}
+
+  public emitEvent<P = any>(
+    type: string,
+    payload?: P,
+    _context?: GraphContext<T>
+  ): void {
+    this.eventEmitter.emit(type, payload);
+  }
+
+  setupEventListeners(): void {
+    const allEvents = new Set<string>();
+    for (const node of this.nodes.values()) {
+      if (node.events) {
+        node.events.forEach((evt) => allEvents.add(evt));
+      }
+    }
+    for (const evt of allEvents) {
+      this.eventEmitter.removeAllListeners(evt);
+    }
+
+    for (const node of this.nodes.values()) {
+      if (node.events && node.events.length > 0) {
+        node.events.forEach((event) => {
+          this.eventEmitter.on(
+            event,
+            async (data?: Partial<GraphContext<T>>) => {
+              const freshContext = structuredClone(this.context);
+              if (data) Object.assign(freshContext, data);
+
+              await this.executeNode(
+                node.name,
+                freshContext,
+                true
+              );
+            }
+          );
+        });
+      }
+    }
+  }
+
+  setupGraphEventListeners(): void {
+    if (this.graphEvents && this.graphEvents.length > 0) {
+      this.graphEvents.forEach((event) => {
+        this.eventEmitter.on(event, async (data?: Partial<GraphContext<T>>) => {
+          const freshContext = this.createNewContext();
+          if (data) Object.assign(freshContext, data);
+
+          this.eventEmitter.emit("graphStarted", { name: this.name });
+
+          try {
+            if (!this.entryNode) {
+              throw new Error("No entry node defined for graph event handling");
+            }
+
+            await this.executeNode(this.entryNode, freshContext, false);
+
+            this.eventEmitter.emit("graphCompleted", {
+              name: this.name,
+              context: this.context,
+            });
+          } catch (error) {
+            this.eventEmitter.emit("graphError", { name: this.name, error });
+            this.globalErrorHandler?.(error as Error, freshContext);
+            throw error;
+          }
+        });
+      });
+    }
+  }
+
+  async waitForEvents(
+    events: string[],
+    timeout: number = 30000
+  ): Promise<any[]> {
+    return new Promise((resolve, reject) => {
+      const receivedEvents = new Map<string, any>();
+      const eventHandlers = new Map();
+      let isResolved = false;
+
+      const cleanup = () => {
+        events.forEach((event) => {
+          const handler = eventHandlers.get(event);
+          if (handler) {
+            this.eventEmitter.removeListener(event, handler);
+          }
+        });
+      };
+
+      events.forEach((event) => {
+        const handler = (eventData: any) => {
+          if (!isResolved) {
+            receivedEvents.set(event, eventData);
+
+            if (events.every((e) => receivedEvents.has(e))) {
+              isResolved = true;
+              clearTimeout(timeoutId);
+              cleanup();
+              resolve(Array.from(receivedEvents.values()));
+            }
+          }
+        };
+
+        eventHandlers.set(event, handler);
+        this.eventEmitter.on(event, handler);
+      });
+
+      const timeoutId = setTimeout(() => {
+        if (!isResolved) {
+          isResolved = true;
+          cleanup();
+          reject(new Error(`Timeout waiting for events: ${events.join(", ")}`));
+        }
+      }, timeout);
+    });
+  }
+
+  on(eventName: string, handler: (...args: any[]) => void): void {
+    this.eventEmitter.on(eventName, handler);
+  }
+
+  emit(eventName: string, data?: any): void {
+    this.lastEvents.set(eventName, data);
+    this.eventEmitter.emit(eventName, data);
+  }
+
+  private createNewContext(): GraphContext<T> {
+    return structuredClone(this.context);
+  }
+
+  private async executeNode(
+    nodeName: string,
+    context: GraphContext<T>,
+    triggeredByEvent: boolean
+  ): Promise<void> {
+    if (!this.nodeExecutor) {
+      throw new Error("NodeExecutor not initialized");
+    }
+
+    const node = this.nodes.get(nodeName);
+    if (!node) {
+      throw new Error(`Node "${nodeName}" not found`);
+    }
+
+    if (node.when) {
+      await this.handleNodeEvents(nodeName, node.when);
+    }
+
+    return this.nodeExecutor.executeNode(nodeName, context, triggeredByEvent);
+  }
+
+  waitForCorrelatedEvents(
+    eventTypes: string[],
+    timeoutMs: number,
+    correlationFn: (events: GraphEvent<T>[]) => boolean
+  ): Promise<GraphEvent<T>[]> {
+    return new Promise((resolve, reject) => {
+      const receivedEvents = new Map<string, GraphEvent<T>>();
+      const eventHandlers = new Map();
+      let isResolved = false;
+
+      const cleanup = () => {
+        eventHandlers.forEach((handler, event) => {
+          this.eventEmitter.removeListener(event, handler);
+        });
+      };
+
+      eventTypes.forEach((eventType) => {
+        const handler = (eventData: any) => {
+          if (!isResolved) {
+            const event: GraphEvent<T> = {
+              type: eventType,
+              payload: eventData,
+              timestamp: Date.now(),
+            };
+            receivedEvents.set(eventType, event);
+
+            if (eventTypes.every((type) => receivedEvents.has(type))) {
+              const events = Array.from(receivedEvents.values());
+              if (correlationFn(events)) {
+                isResolved = true;
+                clearTimeout(timeoutId);
+                cleanup();
+                resolve(events);
+              }
+            }
+          }
+        };
+
+        eventHandlers.set(eventType, handler);
+        this.eventEmitter.on(eventType, handler);
+      });
+
+      const timeoutId = setTimeout(() => {
+        if (!isResolved) {
+          cleanup();
+          reject(
+            new Error(
+              `Timeout waiting for correlated events: ${eventTypes.join(", ")}`
+            )
+          );
+        }
+      }, timeoutMs);
+    });
+  }
+
+  async handleNodeEvents(
+    nodeName: string,
+    config: EventConfig
+  ): Promise<any[]> {
+    const { events, timeout = 30000, strategy } = config;
+
+    return new Promise((resolve, reject) => {
+      const receivedEvents = new Map<string, any>();
+      const eventHandlers = new Map();
+      let isResolved = false;
+
+      events.forEach((event: string) => {
+        const existingEvent = this.lastEvents.get(event);
+        if (existingEvent) {
+          receivedEvents.set(event, {
+            type: event,
+            payload: existingEvent,
+            timestamp: Date.now(),
+          });
+        }
+      });
+
+      const checkEvents = () => {
+        if (isResolved) return;
+
+        const eventsList = Array.from(receivedEvents.values());
+
+        switch (strategy.type) {
+          case "single":
+            if (receivedEvents.size > 0) {
+              resolve(eventsList);
+              isResolved = true;
+            }
+            break;
+
+          case "all":
+          case "correlate":
+            const allReceived = events.every((e: string) =>
+              receivedEvents.has(e)
+            );
+            if (allReceived) {
+              if (strategy.type === "correlate") {
+                const correlated = strategy.correlation?.(eventsList);
+                if (!correlated) return;
+              }
+              resolve(eventsList);
+              isResolved = true;
+            }
+            break;
+        }
+
+        if (isResolved) {
+          cleanup();
+        }
+      };
+
+      events.forEach((event: string) => {
+        if (!receivedEvents.has(event)) {
+          const handler = (eventData: any) => {
+            receivedEvents.set(event, {
+              type: event,
+              payload: eventData,
+              timestamp: Date.now(),
+            });
+            checkEvents();
+          };
+          eventHandlers.set(event, handler);
+          this.eventEmitter.on(event, handler);
+        }
+      });
+
+      const cleanup = () => {
+        eventHandlers.forEach((handler, event) => {
+          this.eventEmitter.removeListener(event, handler);
+        });
+      };
+
+      checkEvents();
+
+      const timeoutId = setTimeout(() => {
+        if (!isResolved) {
+          cleanup();
+          reject(new Error(`Timeout waiting for events: ${events.join(", ")}`));
+        }
+      }, timeout);
+    });
+  }
+}