@ai.ntellect/core 0.7.8 → 1.0.0

package/dist/utils/generate-action-schema.js

@@ -1,44 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSchemaString = exports.generateActionSchema = void 0;
-const zod_1 = require("zod");
-const generateActionSchema = (graphs) => {
-    return graphs
-        .map((graph) => {
-        const rootNode = Array.from(graph.nodes.values())[0];
-        const schemaStr = rootNode.params
-            ? (0, exports.getSchemaString)(rootNode.params)
-            : "No parameters";
-        return `Workflow: ${graph.name}\nParameters: ${schemaStr}`;
-    })
-        .join("\n\n");
-};
-exports.generateActionSchema = generateActionSchema;
-const getSchemaString = (schema) => {
-    if (schema instanceof zod_1.z.ZodObject) {
-        const entries = Object.entries(schema.shape);
-        const fields = entries.map(([key, value]) => {
-            const description = value._def.description;
-            const schemaStr = (0, exports.getSchemaString)(value);
-            return description
-                ? `${key}: ${schemaStr} // ${description}`
-                : `${key}: ${schemaStr}`;
-        });
-        return `z.object({${fields.join(", ")}})`;
-    }
-    if (schema instanceof zod_1.z.ZodArray) {
-        return `z.array(${(0, exports.getSchemaString)(schema.element)})`;
-    }
-    if (schema instanceof zod_1.z.ZodString) {
-        return "z.string()";
-    }
-    if (schema instanceof zod_1.z.ZodNumber) {
-        return "z.number()";
-    }
-    if (schema instanceof zod_1.z.ZodBoolean) {
-        return "z.boolean()";
-    }
-    return `z.unknown()`;
-};
-exports.getSchemaString = getSchemaString;
-//# sourceMappingURL=generate-action-schema.js.map

package/dist/utils/generate-action-schema.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"generate-action-schema.js","sourceRoot":"","sources":["../../utils/generate-action-schema.ts"],"names":[],"mappings":";;;AAAA,6BAAwB;AAGjB,MAAM,oBAAoB,GAAG,CAAC,MAAwB,EAAE,EAAE;IAC/D,OAAO,MAAM;SACV,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE;QACb,MAAM,QAAQ,GAAG,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;QACrD,MAAM,SAAS,GAAG,QAAQ,CAAC,MAAM;YAC/B,CAAC,CAAC,IAAA,uBAAe,EAAC,QAAQ,CAAC,MAAM,CAAC;YAClC,CAAC,CAAC,eAAe,CAAC;QACpB,OAAO,aAAa,KAAK,CAAC,IAAI,iBAAiB,SAAS,EAAE,CAAC;IAC7D,CAAC,CAAC;SACD,IAAI,CAAC,MAAM,CAAC,CAAC;AAClB,CAAC,CAAC;AAVW,QAAA,oBAAoB,wBAU/B;AAEK,MAAM,eAAe,GAAG,CAAC,MAAiB,EAAU,EAAE;IAC3D,IAAI,MAAM,YAAY,OAAC,CAAC,SAAS,EAAE,CAAC;QAClC,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QAC7C,MAAM,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE;YAC1C,MAAM,WAAW,GAAI,KAAa,CAAC,IAAI,CAAC,WAAW,CAAC;YACpD,MAAM,SAAS,GAAG,IAAA,uBAAe,EAAC,KAAkB,CAAC,CAAC;YACtD,OAAO,WAAW;gBAChB,CAAC,CAAC,GAAG,GAAG,KAAK,SAAS,OAAO,WAAW,EAAE;gBAC1C,CAAC,CAAC,GAAG,GAAG,KAAK,SAAS,EAAE,CAAC;QAC7B,CAAC,CAAC,CAAC;QACH,OAAO,aAAa,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC;IAC5C,CAAC;IAED,IAAI,MAAM,YAAY,OAAC,CAAC,QAAQ,EAAE,CAAC;QACjC,OAAO,WAAW,IAAA,uBAAe,EAAC,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC;IACvD,CAAC;IAED,IAAI,MAAM,YAAY,OAAC,CAAC,SAAS,EAAE,CAAC;QAClC,OAAO,YAAY,CAAC;IACtB,CAAC;IAED,IAAI,MAAM,YAAY,OAAC,CAAC,SAAS,EAAE,CAAC;QAClC,OAAO,YAAY,CAAC;IACtB,CAAC;IAED,IAAI,MAAM,YAAY,OAAC,CAAC,UAAU,EAAE,CAAC;QACnC,OAAO,aAAa,CAAC;IACvB,CAAC;IAED,OAAO,aAAa,CAAC;AACvB,CAAC,CAAC;AA9BW,QAAA,eAAe,mBA8B1B"}

package/dist/utils/header-builder.d.ts

@@ -1,12 +0,0 @@
-type HeaderValue = string | string[] | undefined;
-export declare class LLMHeaderBuilder {
-    private headers;
-    private _result;
-    constructor();
-    addHeader(key: string, value: HeaderValue): LLMHeaderBuilder;
-    valueOf(): string;
-    toString(): string;
-    static create(): LLMHeaderBuilder;
-}
-export {};
-//# sourceMappingURL=header-builder.d.ts.map

package/dist/utils/header-builder.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"header-builder.d.ts","sourceRoot":"","sources":["../../utils/header-builder.ts"],"names":[],"mappings":"AAAA,KAAK,WAAW,GAAG,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,CAAC;AAEjD,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,OAAO,CAA2B;IAC1C,OAAO,CAAC,OAAO,CAAS;;IAOxB,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,WAAW,GAAG,gBAAgB;IAiB5D,OAAO,IAAI,MAAM;IAIjB,QAAQ,IAAI,MAAM;IAIlB,MAAM,CAAC,MAAM,IAAI,gBAAgB;CAGlC"}

package/dist/utils/header-builder.js

@@ -1,35 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LLMHeaderBuilder = void 0;
-class LLMHeaderBuilder {
-    constructor() {
-        this.headers = new Map();
-        this._result = "";
-    }
-    addHeader(key, value) {
-        if (Array.isArray(value)) {
-            this.headers.set(key, value.join("\n"));
-        }
-        else {
-            this.headers.set(key, value);
-        }
-        // Build result immediately
-        this._result = Array.from(this.headers.entries())
-            .filter(([_, value]) => value !== undefined)
-            .map(([key, value]) => `# ${key}: ${value}`)
-            .join("\n")
-            .trim();
-        return this;
-    }
-    valueOf() {
-        return this._result;
-    }
-    toString() {
-        return this._result;
-    }
-    static create() {
-        return new LLMHeaderBuilder();
-    }
-}
-exports.LLMHeaderBuilder = LLMHeaderBuilder;
-//# sourceMappingURL=header-builder.js.map

package/dist/utils/header-builder.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"header-builder.js","sourceRoot":"","sources":["../../utils/header-builder.ts"],"names":[],"mappings":";;;AAEA,MAAa,gBAAgB;IAI3B;QACE,IAAI,CAAC,OAAO,GAAG,IAAI,GAAG,EAAE,CAAC;QACzB,IAAI,CAAC,OAAO,GAAG,EAAE,CAAC;IACpB,CAAC;IAED,SAAS,CAAC,GAAW,EAAE,KAAkB;QACvC,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;YACzB,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;QAC1C,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;QAC/B,CAAC;QAED,2BAA2B;QAC3B,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;aAC9C,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,KAAK,SAAS,CAAC;aAC3C,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,GAAG,KAAK,KAAK,EAAE,CAAC;aAC3C,IAAI,CAAC,IAAI,CAAC;aACV,IAAI,EAAE,CAAC;QAEV,OAAO,IAAI,CAAC;IACd,CAAC;IAED,OAAO;QACL,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAED,QAAQ;QACN,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAED,MAAM,CAAC,MAAM;QACX,OAAO,IAAI,gBAAgB,EAAE,CAAC;IAChC,CAAC;CACF;AArCD,4CAqCC"}

package/graph/controller.ts

@@ -1,74 +0,0 @@
-import { ZodSchema } from "zod";
-import { GraphContext } from "../types";
-import { GraphFlow } from "./index";
-import { NodeParams } from "./node";
-
-/**
- * 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 params - Optional array of node parameters 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[],
-    params?: NodeParams[]
-  ): Promise<any[]> {
-    const results = new Map<string, GraphContext<T>>();
-    for (let i = 0; i < graphs.length; i++) {
-      const result = await graphs[i].execute(startNodes[i], params?.[i]);
-      results.set(`${graphs[i].name}-${i}`, result);
-    }
-    return Array.from(results.values());
-  }
-
-  private static async executeGraph<T extends ZodSchema>(
-    graph: GraphFlow<T>,
-    startNode: string,
-    params?: NodeParams
-  ): Promise<GraphContext<T>> {
-    try {
-      return await graph.execute(startNode, params);
-    } 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 params - Optional array of node parameters 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,
-    params?: NodeParams[]
-  ): Promise<GraphContext<T>[]> {
-    const results: GraphContext<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 param = params?.[i + idx];
-          return this.executeGraph(graph, startNodes[i + idx], param);
-        })
-      );
-      results.push(...batchResults);
-    }
-
-    return results;
-  }
-}

package/graph/event-manager.ts

@@ -1,363 +0,0 @@
-import { Observable, Subject, filter } from "rxjs";
-import { ZodSchema } from "zod";
-import { IEventEmitter } from "../interfaces";
-import { GraphContext, GraphEvent, Node } from "../types";
-import { GraphNode } from "./node";
-
-/**
- * Manages event handling and routing for a graph
- * Coordinates event emission, listening, and execution of event-driven nodes
- * @template T - The Zod schema type for validation
- */
-export class GraphEventManager<T extends ZodSchema> {
-  private eventSubject: Subject<GraphEvent<T>> = new Subject();
-  private nodeStreams: Map<string, Observable<GraphEvent<T>>> = new Map();
-  private context: GraphContext<T>;
-  private name: string;
-  private graphEvents?: string[];
-  private entryNode?: string;
-  private globalErrorHandler?: (error: Error, context: GraphContext<T>) => void;
-
-  /**
-   * Creates a new GraphEventManager instance
-   * @param eventEmitter - The event emitter implementation to use
-   * @param nodes - Map of all nodes in the graph
-   * @param name - Name of the graph
-   * @param context - Initial graph context
-   * @param graphEvents - List of events the graph should listen to
-   * @param entryNode - Name of the entry node for graph events
-   * @param globalErrorHandler - Global error handling function
-   * @param nodeExecutor - GraphNode instance for executing nodes
-   */
-  constructor(
-    private eventEmitter: IEventEmitter,
-    private nodes: Map<string, Node<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;
-    this.setupEventStreams();
-  }
-
-  /**
-   * Sets up event streams for all nodes that listen to events
-   */
-  public setupEventStreams(): void {
-    for (const [nodeName, node] of this.nodes.entries()) {
-      if (node.events && node.events.length > 0) {
-        const nodeStream = this.eventSubject.pipe(
-          filter((event) => node.events!.includes(event.type))
-        );
-        this.nodeStreams.set(nodeName, nodeStream);
-      }
-    }
-  }
-
-  /**
-   * Emits an event with optional payload and context
-   * @param type - The type of event to emit
-   * @param payload - Optional payload data
-   * @param context - Optional graph context
-   */
-  public emitEvent<P = any>(
-    type: string,
-    payload?: P,
-    context?: GraphContext<T>
-  ): void {
-    // Éviter la double imbrication des événements
-    const event = {
-      type,
-      payload,
-      timestamp: Date.now(),
-    };
-
-    // Émettre l'événement une seule fois
-    this.eventSubject.next(event);
-    this.eventEmitter.emit(type, payload);
-  }
-
-  /**
-   * Sets up event listeners for all nodes in the graph
-   * Handles cleanup and re-registration of event listeners
-   */
-  setupEventListeners(): void {
-    // First remove only the existing node-based listeners that we might have created previously
-    // We do NOT remove, for example, "nodeStarted" or "nodeCompleted" listeners that test code added.
-    for (const [eventName, listener] of this.eventEmitter
-      .rawListeners("*")
-      .entries()) {
-      // This can be tricky—EventEmitter doesn't directly let you remove by "type" of listener.
-      // Alternatively, we can store references in a separate structure.
-      // For simplicity, let's do a full removeAllListeners() on node-specified events (only),
-      // then re-add them below, but keep the test-based events like "nodeStarted" or "nodeCompleted".
-    }
-
-    // The simplest approach: removeAllListeners for each event that is declared as a node event
-    // so we don't stack up duplicates:
-    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) {
-      // remove only those events that are used by nodes
-      this.eventEmitter.removeAllListeners(evt);
-    }
-
-    // Now re-add the node-based event triggers
-    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);
-
-              // If triggered by an event, we pass "true" so event-driven node will skip `next`.
-              await this.executeNode(
-                node.name,
-                freshContext,
-                undefined,
-                /* triggeredByEvent= */ true
-              );
-            }
-          );
-        });
-      }
-    }
-  }
-
-  /**
-   * Sets up listeners for graph-level events
-   * Handles graph start, completion, and error events
-   */
-  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);
-
-          // Emit "graphStarted"
-          this.eventEmitter.emit("graphStarted", { name: this.name });
-
-          try {
-            // Execute the graph starting from the entry node
-            if (!this.entryNode) {
-              throw new Error("No entry node defined for graph event handling");
-            }
-
-            await this.executeNode(
-              this.entryNode,
-              freshContext,
-              undefined,
-              false
-            );
-
-            // Emit "graphCompleted"
-            this.eventEmitter.emit("graphCompleted", {
-              name: this.name,
-              context: this.context,
-            });
-          } catch (error) {
-            // Emit "graphError"
-            this.eventEmitter.emit("graphError", { name: this.name, error });
-            this.globalErrorHandler?.(error as Error, freshContext);
-            throw error;
-          }
-        });
-      });
-    }
-  }
-
-  /**
-   * Waits for a set of events to occur within a timeout period
-   * @param events - Array of event names to wait for
-   * @param timeout - Maximum time to wait in milliseconds
-   * @returns Promise that resolves with array of received events
-   * @throws Error if timeout occurs before all events are received
-   */
-  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);
-    });
-  }
-
-  /**
-   * Registers an event handler
-   * @param eventName - Name of the event to listen for
-   * @param handler - Function to handle the event
-   */
-  on(eventName: string, handler: (...args: any[]) => void): void {
-    this.eventEmitter.on(eventName, handler);
-  }
-
-  /**
-   * Emits an event through the event emitter
-   * @param eventName - Name of the event to emit
-   * @param data - Optional data to include with the event
-   */
-  emit(eventName: string, data?: any): void {
-    this.eventEmitter.emit(eventName, data);
-  }
-
-  /**
-   * Creates a new context object by cloning the current context
-   * @returns A new graph context instance
-   * @private
-   */
-  private createNewContext(): GraphContext<T> {
-    return structuredClone(this.context);
-  }
-
-  /**
-   * Executes a node with the given parameters
-   * @param nodeName - Name of the node to execute
-   * @param context - Graph context for execution
-   * @param inputs - Input data for the node
-   * @param triggeredByEvent - Whether execution was triggered by an event
-   * @returns Promise that resolves when execution is complete
-   * @throws Error if nodeExecutor is not initialized
-   * @private
-   */
-  private async executeNode(
-    nodeName: string,
-    context: GraphContext<T>,
-    inputs: any,
-    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`);
-    }
-
-    // Attendre les événements si waitForEvents est configuré
-    if (node.waitForEvents) {
-      try {
-        await this.waitForEvents(
-          node.waitForEvents.events,
-          node.waitForEvents.timeout
-        );
-      } catch (error) {
-        throw new Error(
-          `Timeout waiting for events in node "${nodeName}": ${
-            (error as Error).message
-          }`
-        );
-      }
-    }
-
-    return this.nodeExecutor.executeNode(
-      nodeName,
-      context,
-      inputs,
-      triggeredByEvent
-    );
-  }
-
-  async 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>>();
-      let isResolved = false;
-
-      const timeoutId = setTimeout(() => {
-        if (!isResolved) {
-          isResolved = true;
-          eventTypes.forEach((type) => {
-            this.eventEmitter.removeAllListeners(type);
-          });
-          reject(
-            new Error(
-              `Timeout waiting for correlated events: ${eventTypes.join(", ")}`
-            )
-          );
-        }
-      }, timeoutMs);
-
-      const checkCorrelation = () => {
-        if (eventTypes.every((type) => receivedEvents.has(type))) {
-          const events = Array.from(receivedEvents.values());
-          if (correlationFn(events)) {
-            if (!isResolved) {
-              isResolved = true;
-              clearTimeout(timeoutId);
-              eventTypes.forEach((type) => {
-                this.eventEmitter.removeAllListeners(type);
-              });
-              resolve(events);
-            }
-          }
-        }
-      };
-
-      eventTypes.forEach((eventType) => {
-        this.eventEmitter.on(eventType, (eventData: any) => {
-          receivedEvents.set(eventType, {
-            type: eventType,
-            payload: eventData,
-            timestamp: Date.now(),
-          });
-          checkCorrelation();
-        });
-      });
-    });
-  }
-}