@ai.ntellect/core 0.7.13 → 0.8.0

package/types/agent.ts

@@ -0,0 +1,174 @@
+import { GraphFlow } from "@/graph";
+import { z } from "zod";
+
+/**
+ * Represents an action that has been executed by the agent
+ * @interface ExecutedAction
+ * @property {string} name - The name of the executed action
+ * @property {boolean} isExecuted - Whether the action was successfully executed
+ * @property {string | null} [error] - Optional error message if the action failed
+ * @property {any} result - The result of the action execution
+ * @property {string} timestamp - When the action was executed
+ */
+export type ExecutedAction = {
+  name: string;
+  isExecuted: boolean;
+  error?: string | null;
+  result: any;
+  timestamp: string;
+};
+
+/**
+ * Represents the context in which an agent operates
+ * @interface AgentContext
+ * @property {Object} input - The input provided to the agent
+ * @property {string} input.raw - The raw input text
+ * @property {number[]} [input.embedding] - Optional vector embedding of the input
+ * @property {ActionSchema[]} actions - List of actions available to the agent
+ * @property {string} response - The agent's response
+ * @property {string} [knowledge] - Optional knowledge base or context
+ * @property {ExecutedAction[]} executedActions - History of executed actions
+ */
+export type AgentContext = {
+  input: {
+    raw: string;
+    embedding?: number[];
+  };
+  actions: ActionSchema[];
+  response: string;
+  knowledge?: string;
+  executedActions: ExecutedAction[];
+};
+
+export const AgentContextSchema = z.object({
+  input: z.object({
+    raw: z.string(),
+    embedding: z.array(z.number()).optional(),
+  }),
+  actions: z.array(
+    z.object({
+      name: z.string(),
+      parameters: z.array(
+        z.object({
+          name: z.string(),
+          value: z.any(),
+        })
+      ),
+      isExecuted: z.boolean().optional(),
+      result: z.any().optional(),
+    })
+  ),
+  knowledge: z.string().optional(),
+  response: z.string(),
+  executedActions: z
+    .array(
+      z.object({
+        name: z.string(),
+        result: z.any(),
+        timestamp: z.string(),
+      })
+    )
+    .optional(),
+});
+
+/**
+ * Represents a section of the prompt with a title and content
+ * @interface PromptSection
+ * @property {string} title - The title of the prompt section
+ * @property {string | ((context: AgentContext) => string | Promise<string>)} content - The content or a function to generate content
+ */
+export type PromptSection = {
+  title: string;
+  content: string | ((context: AgentContext) => string | Promise<string>);
+};
+
+/**
+ * Supported LLM providers
+ */
+export type LLMProvider = "openai" | "anthropic" | "custom";
+
+/**
+ * Supported LLM models
+ */
+export type LLMModel = "gpt-4" | "gpt-3.5-turbo" | "claude-2" | string;
+
+export type ExecutorConfig = {
+  llmConfig: LLMConfig;
+  verbose?: boolean;
+};
+
+/**
+ * Configuration for the Agent
+ * @type AssistantConfig
+ * @extends {Omit<ExecutorConfig, "verbose">}
+ * @property {string} role - The function/job of the assistant (e.g., "Email Assistant")
+ * @property {string} goal - The specific objective the assistant tries to achieve
+ * @property {string} backstory - The personality and behavioral traits of the assistant
+ * @property {any[]} [tools] - Optional tools the assistant can use
+ * @property {any} [memory] - Optional memory system
+ * @property {boolean} [verbose] - Whether to log detailed information
+ */
+export type AgentConfig = {
+  role: string;
+  goal: string;
+  backstory: string;
+  tools: GraphFlow<any>[];
+  memory?: any;
+  verbose?: boolean;
+  llmConfig: ExecutorConfig["llmConfig"];
+};
+
+/**
+ * Represents the schema of an action that can be performed by the agent
+ * @interface ActionSchema
+ * @property {string} name - The name of the action
+ * @property {Array<{name: string, value: any}>} parameters - The parameters required for the action
+ */
+export type ActionSchema = {
+  name: string;
+  parameters: Array<{ name: string; value: any }>;
+};
+
+/**
+ * Represents the output of the agent's decision-making process
+ * @interface DecisionOutput
+ * @property {ActionSchema[]} actions - The actions to be executed
+ * @property {string} response - The agent's response message
+ */
+export type DecisionOutput = {
+  actions: ActionSchema[];
+  response: string;
+};
+
+/**
+ * Configuration for the Language Model
+ * @interface LLMConfig
+ * @property {LLMProvider} provider - The LLM provider to use
+ * @property {string} apiKey - API key for the provider
+ * @property {LLMModel} model - The specific model to use
+ * @property {number} [temperature] - Optional temperature parameter for response randomness
+ * @property {number} [maxTokens] - Optional maximum tokens for the response
+ * @property {Function} [customCall] - Optional custom implementation for API calls
+ */
+export type LLMConfig = {
+  provider: LLMProvider;
+  apiKey: string;
+  model: LLMModel;
+  temperature?: number;
+  maxTokens?: number;
+  customCall?: (
+    prompt: string | PromptInput,
+    schema: z.ZodType<any>
+  ) => Promise<any>;
+};
+
+/**
+ * Structure for prompt input to the LLM
+ * @interface PromptInput
+ * @property {string} system - The system message/context
+ * @property {string} user - The user's input message
+ */
+export type PromptInput = {
+  system: string;
+  user: string;
+};

package/types/index.ts

@@ -14,10 +14,12 @@ import { IEventEmitter } from "../interfaces";
  */
 export interface CreateMemoryInput {
   id?: string;
-  data: string;
+  content: string;
+  metadata?: Record<string, any>;
   embedding?: number[];
   roomId: string;
   ttl?: number;
+  type?: string;
 }
 
 /**
@@ -32,7 +34,8 @@ export interface CreateMemoryInput {
  */
 export interface BaseMemoryType {
   id: string;
-  data: string;
+  content: string;
+  metadata?: Record<string, any>;
   embedding?: number[];
   roomId: string;
   createdAt: Date;
@@ -73,6 +76,22 @@ export type GraphContext<T extends ZodSchema> = {
   [key: string]: any;
 };
 
+/**
+ * Configuration for event handling in a node
+ */
+export type EventStrategy = {
+  type: "single" | "all" | "correlate";
+  correlation?: (events: any[]) => boolean;
+};
+
+export type EventConfig = {
+  events: string[];
+  timeout?: number;
+  strategy: EventStrategy;
+  onSuccess?: (events: any[]) => Promise<void>;
+  onTimeout?: () => Promise<void>;
+};
+
 /**
  * Interface representing a node in the graph
  * @interface
@@ -80,7 +99,7 @@ export type GraphContext<T extends ZodSchema> = {
  * @template I - Input schema type
  * @template O - Output schema type
  */
-export type GraphNodeConfig<T extends ZodSchema, P = any> = {
+export interface GraphNodeConfig<T extends ZodSchema, P = any> {
   /** Name of the node */
   name: string;
   /** Description of the node */
@@ -106,16 +125,8 @@ export type GraphNodeConfig<T extends ZodSchema, P = any> = {
     | ((context: GraphContext<T>) => string[]);
   /** Array of event names that trigger this node */
   events?: string[];
-  /** Wait for a single event before continuing */
-  waitForEvent?: boolean;
-  /** Wait for multiple events configuration */
-  waitForEvents?: WaitForEvents;
-  /** Event correlation configuration */
-  correlateEvents?: {
-    events: string[];
-    timeout: number;
-    correlation: (events: any[]) => boolean;
-  };
+  /** Event handling configuration */
+  when?: EventConfig;
   /** Retry configuration */
   retry?: {
     /** Maximum number of retry attempts */
@@ -129,7 +140,8 @@ export type GraphNodeConfig<T extends ZodSchema, P = any> = {
   };
   /** Error handler function */
   onError?: (error: Error) => void;
-};
+  agent?: string;
+}
 
 /**
  * Interface for graph definition
@@ -155,6 +167,16 @@ export type GraphConfig<T extends ZodSchema> = {
   events?: string[];
 };
 
+/**
+ * Type for graph execution result
+ * @template T - Schema type
+ */
+export type GraphExecutionResult<T extends ZodSchema> = {
+  graphName: string;
+  nodeName: string;
+  context: GraphContext<T>;
+};
+
 /* ======================== MEILISEARCH ======================== */
 
 /**
@@ -183,15 +205,59 @@ export type MeilisearchSettings = {
   sortableAttributes?: string[];
 };
 
-export interface GraphEvent<T extends ZodSchema> {
+export type GraphEvent<T extends ZodSchema> = {
   type: string;
   payload?: any;
   timestamp: number;
-}
+};
 
-export interface WaitForEvents {
+export type WaitForEvents<T extends ZodSchema> = {
   events: string[];
   timeout?: number;
   strategy: "all" | "any" | "race";
   onSuccess?: <T extends ZodSchema>(context: GraphContext<T>) => Promise<void>;
-}
+};
+
+/**
+ * Configuration interface for NLP Engine
+ * @interface NLPConfig
+ * @property {any} [corpus] - Training corpus data
+ * @property {Record<string, any>} [responses] - Response templates
+ * @property {Record<string, any>} [entities] - Entity definitions
+ * @property {string} [language] - Language code (default: 'en')
+ * @property {number} [threshold] - Entity recognition threshold (default: 0.5)
+ * @property {string} [path] - Path to save/load model
+ */
+export type NLPConfig = {
+  corpus?: any;
+  responses?: Record<string, any>;
+  entities?: Record<string, any>;
+  language?: string;
+  threshold?: number;
+  path?: string;
+};
+
+/**
+ * Type definition for action handlers
+ * @callback ActionHandler
+ * @param {any} data - Input data for the action
+ * @returns {Promise<any>} Result of the action
+ */
+export type ActionHandler = (data: any) => Promise<any>;
+
+/**
+ * Options for the observer
+ * @typedef {Object} ObserverOptions
+ * @property {number} [debounce] - Debounce time in milliseconds
+ * @property {number} [delay] - Delay time in milliseconds
+ * @property {boolean} [stream] - Whether to stream the response
+ * @property {(string | number)[]} [properties] - Properties to observe
+ */
+export type 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;
+};