@ai.ntellect/core 0.7.14 → 0.8.0

package/graph/observer.ts

@@ -11,25 +11,15 @@ import {
   filter,
   map,
   share,
-  startWith,
   take,
   takeUntil,
-  timeout,
 } from "rxjs/operators";
 import { ZodSchema } from "zod";
 import { GraphObservable } from "../interfaces";
-import { GraphContext, GraphEvent } from "../types";
+import { GraphContext, GraphEvent, ObserverOptions } from "../types";
+import { GraphEventManager } from "./event-manager";
 import { GraphFlow } from "./index";
 
-interface ObserverOptions {
-  debounce?: number;
-  delay?: number;
-  stream?: boolean;
-  properties?: (string | number)[]; // Accepte uniquement string ou number comme clés
-  onStreamLetter?: (data: { letter: string; property: string }) => void;
-  onStreamComplete?: () => void;
-}
-
 /**
  * GraphObserver class provides reactive observation capabilities for a GraphFlow instance
  * It allows monitoring state changes, node updates, and specific events in the graph
@@ -40,18 +30,13 @@ export class GraphObserver<T extends ZodSchema> {
     private graph: GraphFlow<T>,
     private eventSubject: Subject<GraphEvent<T>>,
     private stateSubject: BehaviorSubject<GraphContext<T>>,
-    private destroySubject: Subject<void>
+    private destroySubject: Subject<void>,
+    private eventManager: GraphEventManager<T>
   ) {}
 
   /**
    * Observes the entire graph state changes
    * @param options Configuration options for the observation
-   * @param options.debounce Debounce time in milliseconds
-   * @param options.delay Delay between emissions in milliseconds
-   * @param options.stream If true, streams the specified properties letter by letter
-   * @param options.properties List of properties to stream
-   * @param options.onStreamLetter Callback for each letter emitted during streaming
-   * @param options.onStreamComplete Callback when streaming is complete
    * @returns An Observable that emits the complete graph context whenever it changes
    */
   state(options: ObserverOptions = {}): GraphObservable<T> {
@@ -78,7 +63,6 @@ export class GraphObserver<T extends ZodSchema> {
         )
         .subscribe(subscriber);
 
-      // Stream the specified properties if specified
       if (options.stream && options.properties) {
         const context = this.stateSubject.getValue();
         options.properties.forEach((property) => {
@@ -99,7 +83,6 @@ export class GraphObserver<T extends ZodSchema> {
       return () => subscription.unsubscribe();
     });
 
-    // Extend the observable with our custom methods
     return Object.assign(baseObservable, {
       state: () => this.stateSubject.asObservable(),
       node: (nodeName: string) =>
@@ -140,214 +123,25 @@ export class GraphObserver<T extends ZodSchema> {
     }) as GraphObservable<T>;
   }
 
-  /**
-   * Observes state changes for a specific node
-   * @param name - The name of the node to observe
-   * @returns An Observable that emits the graph context when the specified node changes
-   */
-  node(name: string): Observable<GraphContext<T>> {
-    return this.eventSubject.pipe(
-      filter(
-        (event) =>
-          event.type === "nodeStateChanged" && event.payload?.name === name
-      ),
-      map((event) => event.payload.context),
-      distinctUntilChanged(
-        (prev, curr) => JSON.stringify(prev) === JSON.stringify(curr)
-      ),
-      takeUntil(this.destroySubject),
-      share()
-    );
-  }
-
-  /**
-   * Observes state changes for multiple nodes
-   * @param names - Array of node names to observe
-   * @returns An Observable that emits the graph context when any of the specified nodes change
-   */
-  nodes(names: string[]): Observable<GraphContext<T>> {
-    return this.eventSubject.pipe(
-      filter(
-        (event) =>
-          names.includes(event.payload?.name ?? "") &&
-          event.type === "nodeStateChanged"
-      ),
-      map(() => this.graph.getContext()),
-      distinctUntilChanged(
-        (prev, curr) => JSON.stringify(prev) === JSON.stringify(curr)
-      ),
-      takeUntil(this.destroySubject),
-      share()
-    );
-  }
-
-  /**
-   * Observes specific properties of the graph context
-   * @param keys - Single or multiple property keys to observe
-   * @returns An Observable that emits an object containing only the specified properties
-   * @template K - The key of the property to observe from GraphContext<T>
-   */
-  property<K extends keyof GraphContext<T>>(
-    keys: K | K[]
-  ): Observable<{ [P in K]: GraphContext<T>[P] } & { name: string }> {
-    const properties = Array.isArray(keys) ? keys : [keys];
-
-    return this.eventSubject.pipe(
-      filter(
-        (event) =>
-          event.type === "nodeStateChanged" &&
-          properties.some((key) => event.payload?.property === key)
-      ),
-      map((event) => ({
-        ...properties.reduce(
-          (obj, key) => ({
-            ...obj,
-            [key]: event.payload.context[key],
-          }),
-          {} as { [P in K]: GraphContext<T>[P] }
-        ),
-        name: event.payload.name as string,
-      })),
-      startWith({
-        ...properties.reduce(
-          (obj, key) => ({
-            ...obj,
-            [key]: this.stateSubject.value[key],
-          }),
-          {}
-        ),
-        name: "initial",
-      } as { [P in K]: GraphContext<T>[P] } & { name: string }),
-      distinctUntilChanged(
-        (prev, curr) => JSON.stringify(prev) === JSON.stringify(curr)
-      ),
-      share()
-    );
-  }
-
-  /**
-   * Observes specific events in the graph
-   * @param type - The type of event to observe
-   * @returns An Observable that emits events of the specified type
-   */
-  event(type: string): Observable<GraphEvent<T>> {
-    return this.eventSubject.pipe(
-      filter((event) => event.type === type),
-      map((event) => event),
-      takeUntil(this.destroySubject),
-      share()
-    );
-  }
-
-  /**
-   * Waits for a specific condition to be met on an observable
-   * @param observable - The Observable to watch
-   * @param predicate - A function that returns true when the desired condition is met
-   * @returns A Promise that resolves with the value when the predicate returns true
-   * @template R - The type of value emitted by the observable
-   */
-  until<R>(
-    observable: Observable<R>,
-    predicate: (value: R) => boolean
-  ): Promise<R> {
-    return new Promise((resolve) => {
-      const subscription = observable.subscribe({
-        next: (value) => {
-          if (predicate(value)) {
-            subscription.unsubscribe();
-            resolve(value);
-          }
-        },
-      });
-    });
-  }
-
   /**
    * Waits for correlated events to occur and validates them using a correlation function
-   * @param eventTypes - Array of event types to wait for
-   * @param timeoutMs - Timeout duration in milliseconds
-   * @param correlationFn - Function to validate the correlation between events
-   * @returns Promise that resolves when all correlated events are received
    */
   waitForCorrelatedEvents(
     eventTypes: string[],
     timeoutMs: number,
     correlationFn: (events: GraphEvent<T>[]) => boolean
   ): Promise<GraphEvent<T>[]> {
-    return new Promise((resolve, reject) => {
-      const eventObservables = eventTypes.map((eventType) =>
-        this.eventSubject.pipe(
-          filter((event): event is GraphEvent<T> => {
-            return event.type === eventType && "timestamp" in event;
-          }),
-          take(1)
-        )
-      );
-
-      combineLatest(eventObservables)
-        .pipe(timeout(timeoutMs), take(1))
-        .subscribe({
-          next: (events) => {
-            if (correlationFn(events)) {
-              resolve(events);
-            } else {
-              reject(new Error(`Correlation validation failed`));
-            }
-          },
-          error: (error) => reject(error),
-        });
-    });
-  }
-
-  /**
-   * Observes the current state of the graph
-   * @returns Observable that emits the current graph context
-   */
-  observeState(): Observable<GraphContext<T>> {
-    return this.stateSubject.asObservable().pipe(
-      takeUntil(this.destroySubject),
-      distinctUntilChanged(
-        (prev, curr) => JSON.stringify(prev) === JSON.stringify(curr)
-      )
-    );
-  }
-
-  /**
-   * Observes specific event types in the graph
-   * @param eventType - The type of event to observe
-   * @returns Observable that emits events of the specified type
-   */
-  observeEvents(eventType: string): Observable<GraphEvent<T>> {
-    return this.eventSubject.asObservable().pipe(
-      takeUntil(this.destroySubject),
-      filter((event) => event.type === eventType)
-    );
-  }
-
-  /**
-   * Observes state changes for a specific node
-   * @param nodeName - The name of the node to observe
-   * @returns Observable that emits the graph context when the specified node changes
-   */
-  observeNodeState(nodeName: string): Observable<GraphContext<T>> {
-    return this.eventSubject.asObservable().pipe(
-      takeUntil(this.destroySubject),
-      filter(
-        (event) =>
-          event.type === "nodeStateChanged" && event.payload?.name === nodeName
-      ),
-      map(() => this.stateSubject.value)
+    return this.eventManager.waitForCorrelatedEvents(
+      eventTypes,
+      timeoutMs,
+      correlationFn
     );
   }
 
   /**
    * Streams a message letter by letter with a specified delay
-   * @param message - The message to stream
-   * @param delayMs - The delay in milliseconds between each letter
-   * @param property - The property name being streamed
-   * @returns An Observable that emits each letter of the message along with its property
    */
-  streamMessage(
+  private streamMessage(
     message: string,
     delayMs: number,
     property: string

package/index.ts

@@ -11,6 +11,8 @@
  * - Utility functions for action schema generation and header building
  */
 
+export * from "./modules/agent/agent";
+
 export * from "./graph/controller";
 export * from "./graph/event-manager";
 export * from "./graph/index";
@@ -18,16 +20,9 @@ export * from "./graph/node";
 export * from "./graph/observer";
 export * from "./graph/visualizer";
 
-export * from "./modules/memory";
-export * from "./modules/memory/adapters/in-memory";
-export * from "./modules/memory/adapters/meilisearch";
-export * from "./modules/memory/adapters/redis";
-
 export * from "./interfaces";
 export * from "./modules/agenda";
-export * from "./modules/agenda/adapters/node-cron";
 export * from "./modules/embedding";
-export * from "./modules/embedding/adapters/ai";
 
 export * from "./types";
 

package/interfaces/index.ts

@@ -5,6 +5,7 @@ import {
   CreateMemoryInput,
   GraphContext,
   GraphEvent,
+  GraphNodeConfig,
   ScheduledRequest,
   SchemaType,
 } from "../types";
@@ -546,3 +547,14 @@ export interface GraphObservable<T extends ZodSchema> extends Observable<any> {
     predicate: (state: any) => boolean
   ): Promise<any>;
 }
+
+export interface NLPNodeConfig<T extends ZodSchema>
+  extends Omit<GraphNodeConfig<T>, "execute"> {
+  nlpConfig: {
+    corpus?: any;
+    responses?: Record<string, any>;
+    entities?: Record<string, any>;
+    language?: string;
+  };
+  intentHandlers?: Record<string, (data: any) => Promise<any>>;
+}

package/modules/agent/agent.ts

@@ -0,0 +1,108 @@
+import { GraphFlow } from "../../graph/index";
+import {
+  AgentConfig,
+  AgentContext,
+  AgentContextSchema,
+} from "../../types/agent";
+import { BaseAgent } from "./base";
+import { GenericExecutor } from "./generic-executor";
+
+/**
+ * A generic assistant that can be configured with different roles, goals, and personalities
+ * @class Agent
+ * @example
+ * const assistant = new Agent({
+ *   role: "Email Assistant",
+ *   goal: "Help users send emails efficiently",
+ *   backstory: "I am a professional and friendly assistant who specializes in email communication",
+ *   llmConfig: { provider: "openai", model: "gpt-4" }
+ *   tools: []
+ * });
+ */
+export class Agent {
+  private executor: GenericExecutor;
+  private workflow: GraphFlow<typeof AgentContextSchema>;
+
+  /**
+   * Creates an instance of Agent
+   * @param {AgentConfig} config - Configuration for the agent
+   */
+  constructor(config: AgentConfig) {
+    const agent = new BaseAgent({
+      role: config.role,
+      goal: config.goal,
+      backstory: config.backstory,
+      tools: config.tools,
+      memory: config.memory,
+      llmConfig: config.llmConfig,
+    });
+
+    this.executor = new GenericExecutor(agent, config.tools, {
+      llmConfig: config.llmConfig,
+      verbose: config.verbose,
+    });
+
+    this.workflow = this.setupWorkflow();
+  }
+
+  /**
+   * Sets up the workflow for processing inputs and executing actions
+   * @private
+   * @returns {GraphFlow<typeof AgentContextSchema>} The configured workflow
+   */
+  private setupWorkflow(): GraphFlow<typeof AgentContextSchema> {
+    return new GraphFlow("assistant", {
+      name: "assistant",
+      schema: AgentContextSchema,
+      context: {
+        input: { raw: "" },
+        actions: [],
+        response: "",
+        executedActions: [],
+      },
+      nodes: [
+        {
+          name: "process",
+          execute: async (context) => {
+            const agentContext = context as unknown as AgentContext;
+            const decision = await this.executor.makeDecision(agentContext);
+            context.actions = decision.actions;
+            context.response = decision.response;
+          },
+          next: (context) => (context.actions.length > 0 ? ["execute"] : []),
+        },
+        {
+          name: "execute",
+          execute: async (context) => {
+            console.log(`Executing actions:`);
+            console.log(context.actions);
+            const timestamp = new Date().toISOString();
+            context.knowledge = `Date: ${timestamp}\n${JSON.stringify(
+              context.actions
+            )}`;
+            await this.executor.executeActions(
+              context.actions,
+              context as unknown as AgentContext
+            );
+          },
+          next: ["process"],
+        },
+      ],
+    });
+  }
+
+  /**
+   * Processes an input string through the agent's workflow
+   * @param {string} input - The input string to process
+   * @returns {Promise<AgentContext>} The resulting context after processing
+   */
+  public async process(input: string): Promise<AgentContext> {
+    await this.workflow.execute("process", undefined, {
+      input: { raw: input },
+      actions: [],
+      response: "",
+    });
+
+    return this.workflow.getContext() as unknown as AgentContext;
+  }
+}

package/modules/agent/base/executor.ts

@@ -0,0 +1,100 @@
+import { BaseAgent } from ".";
+import { GraphFlow } from "../../../graph";
+import {
+  ActionSchema,
+  AgentContext,
+  DecisionOutput,
+} from "../../../types/agent";
+
+/**
+ * Abstract base class for agent executors that handle action execution
+ * @abstract
+ * @class AgentExecutor
+ */
+export abstract class AgentExecutor {
+  protected agent: BaseAgent;
+  protected availableGraphs: Map<string, GraphFlow<any>>;
+
+  /**
+   * Creates an instance of AgentExecutor
+   * @param {BaseAgent} agent - The agent instance this executor is tied to
+   * @param {GraphFlow<any>[]} graphs - Array of available graph flows that can be executed
+   */
+  constructor(agent: BaseAgent, graphs: GraphFlow<any>[]) {
+    this.agent = agent;
+    this.availableGraphs = new Map(graphs.map((g) => [g.name, g]));
+  }
+
+  /**
+   * Makes a decision based on the current context
+   * @abstract
+   * @param {any} context - The context to base the decision on
+   * @returns {Promise<DecisionOutput>} The decision output containing actions and response
+   */
+  abstract makeDecision(context: any): Promise<DecisionOutput>;
+
+  /**
+   * Executes a list of actions in the given context
+   * @param {ActionSchema[]} actions - Array of actions to execute
+   * @param {AgentContext} context - The context in which to execute the actions
+   * @returns {Promise<void>}
+   */
+  async executeActions(
+    actions: ActionSchema[],
+    context: AgentContext
+  ): Promise<void> {
+    const workflowsToExecute: GraphFlow<any>[] = [];
+    const startNodes: string[] = [];
+    const inputs: any[] = [];
+
+    for (const action of actions) {
+      const workflow = this.availableGraphs.get(action.name);
+      if (!workflow) continue;
+
+      workflowsToExecute.push(workflow);
+      startNodes.push(workflow.getNodes()[0].name);
+      inputs.push(this.prepareActionInputs(action.parameters));
+    }
+
+    if (workflowsToExecute.length > 0) {
+      await this.executeWorkflows(
+        workflowsToExecute,
+        startNodes,
+        inputs,
+        context
+      );
+    }
+  }
+
+  /**
+   * Prepares the input parameters for an action
+   * @private
+   * @param {Array<{name: string, value: any}>} parameters - Array of parameter objects
+   * @returns {Record<string, any>} Object with parameter names as keys and their values
+   */
+  private prepareActionInputs(
+    parameters: Array<{ name: string; value: any }>
+  ): Record<string, any> {
+    return parameters.reduce((acc, param) => {
+      acc[param.name] = param.value;
+      return acc;
+    }, {} as Record<string, any>);
+  }
+
+  /**
+   * Executes multiple workflows with their respective inputs
+   * @protected
+   * @abstract
+   * @param {GraphFlow<any>[]} workflows - Array of workflows to execute
+   * @param {string[]} startNodes - Array of starting node names for each workflow
+   * @param {any[]} inputs - Array of inputs for each workflow
+   * @param {AgentContext} context - The context in which to execute the workflows
+   * @returns {Promise<void>}
+   */
+  protected abstract executeWorkflows(
+    workflows: GraphFlow<any>[],
+    startNodes: string[],
+    inputs: any[],
+    context: AgentContext
+  ): Promise<void>;
+}

package/modules/agent/base/index.ts

@@ -0,0 +1,99 @@
+import { AgentConfig } from "@/types/agent";
+import { BaseMemoryType } from "../../../types";
+import { Memory } from "../../memory";
+
+/**
+ * Base agent class that handles role, goal, and personality management
+ * @class BaseAgent
+ */
+export class BaseAgent {
+  private config: AgentConfig;
+  private memory?: Memory;
+
+  constructor(config: AgentConfig) {
+    this.config = config;
+    this.memory = config.memory;
+  }
+
+  async execute(context: any, inputs?: any): Promise<any> {
+    // Log execution if verbose
+    if (this.config.verbose) {
+      console.log(`Agent ${this.config.role} executing...`);
+      console.log("Context:", context);
+      console.log("Inputs:", inputs);
+    }
+
+    // Store context in memory if available
+    if (this.memory) {
+      await this.storeInMemory({
+        type: "execution",
+        content: JSON.stringify({ context, inputs }),
+        metadata: {
+          role: this.config.role,
+          timestamp: new Date().toISOString(),
+        },
+      });
+    }
+
+    // Execute tools if available
+    if (this.config.tools) {
+      for (const tool of this.config.tools) {
+        try {
+          const result = await tool.execute(context, inputs);
+          context = { ...context, ...result };
+        } catch (error) {
+          console.error(`Tool execution failed:`, error);
+        }
+      }
+    }
+
+    return context;
+  }
+
+  private async storeInMemory(data: {
+    type: string;
+    content: string;
+    metadata?: Record<string, any>;
+  }): Promise<BaseMemoryType | undefined> {
+    if (!this.memory) return;
+
+    return this.memory.createMemory({
+      content: data.content,
+      metadata: data.metadata,
+      roomId: "default",
+    });
+  }
+
+  public async recall(query: string): Promise<BaseMemoryType[]> {
+    if (!this.memory) return [];
+
+    return this.memory.getMemoryByIndex(query, {
+      roomId: "default",
+      limit: 10,
+    });
+  }
+
+  /**
+   * Get the agent's role - what function/job it performs
+   * @returns {string} The agent's role
+   */
+  public getRole(): string {
+    return this.config.role;
+  }
+
+  /**
+   * Get the agent's goal - what it tries to achieve
+   * @returns {string} The agent's goal
+   */
+  public getGoal(): string {
+    return this.config.goal;
+  }
+
+  /**
+   * Get the agent's backstory - its personality and behavioral traits
+   * @returns {string} The agent's backstory
+   */
+  public getBackstory(): string {
+    return this.config.backstory;
+  }
+}