@ai.ntellect/core 0.8.3 → 1.1.0

package/dist/modules/memory/index.js

@@ -1,104 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Memory = void 0;
-const interfaces_1 = require("../../interfaces");
-/**
- * @module Memory
- * @description A module for managing memory storage and retrieval operations.
- * Implements the BaseMemory abstract class and provides concrete implementations
- * for memory-related operations using the provided adapter.
- * @extends {BaseMemory}
- */
-class Memory extends interfaces_1.BaseMemory {
-    /**
-     * Creates an instance of Memory
-     * @param {IMemoryAdapter} adapter - The memory adapter implementation to use
-     */
-    constructor(adapter) {
-        super(adapter);
-    }
-    /**
-     * Initializes the memory module with default room
-     * @returns {Promise<void>}
-     */
-    init() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.adapter.init("default");
-        });
-    }
-    /**
-     * Creates a new memory entry
-     * @param {CreateMemoryInput & { embedding?: number[] }} input - Memory data with optional embedding
-     * @returns {Promise<BaseMemoryType | undefined>} Created memory or undefined
-     */
-    createMemory(input) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.adapter.createMemory(input);
-        });
-    }
-    /**
-     * Retrieves a memory by ID and room ID
-     * @param {string} id - Memory identifier
-     * @param {string} roomId - Room identifier
-     * @returns {Promise<BaseMemoryType | null>} Memory entry or null if not found
-     */
-    getMemoryById(id, roomId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.adapter.getMemoryById(id, roomId);
-        });
-    }
-    /**
-     * Searches for memories based on query and options
-     * @param {string} query - Search query
-     * @param {Object} options - Search options
-     * @param {string} options.roomId - Room identifier
-     * @param {number} [options.limit] - Maximum number of results to return
-     * @returns {Promise<BaseMemoryType[]>} Array of matching memories
-     */
-    getMemoryByIndex(query, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.adapter.getMemoryByIndex(query, options);
-        });
-    }
-    /**
-     * Retrieves all memories for a specific room
-     * @param {string} roomId - Room identifier
-     * @returns {Promise<BaseMemoryType[]>} Array of all memories in the room
-     */
-    getAllMemories(roomId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.adapter.getAllMemories(roomId);
-        });
-    }
-    /**
-     * Deletes a specific memory
-     * @param {string} id - Memory identifier
-     * @param {string} roomId - Room identifier
-     * @returns {Promise<void>}
-     */
-    clearMemoryById(id, roomId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.adapter.clearMemoryById(id, roomId);
-        });
-    }
-    /**
-     * Clears all memories across all rooms
-     * @returns {Promise<void>}
-     */
-    clearAllMemories() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.adapter.clearAllMemories();
-        });
-    }
-}
-exports.Memory = Memory;
-//# sourceMappingURL=index.js.map

package/dist/modules/memory/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../modules/memory/index.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,iDAA8D;AAG9D;;;;;;GAMG;AACH,MAAa,MAAO,SAAQ,uBAAU;IACpC;;;OAGG;IACH,YAAY,OAAuB;QACjC,KAAK,CAAC,OAAO,CAAC,CAAC;IACjB,CAAC;IAED;;;OAGG;IACG,IAAI;;YACR,MAAM,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QACrC,CAAC;KAAA;IAED;;;;OAIG;IACG,YAAY,CAChB,KAAmD;;YAEnD,OAAO,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;QAC1C,CAAC;KAAA;IAED;;;;;OAKG;IACG,aAAa,CACjB,EAAU,EACV,MAAc;;YAEd,OAAO,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,EAAE,EAAE,MAAM,CAAC,CAAC;QAChD,CAAC;KAAA;IAED;;;;;;;OAOG;IACG,gBAAgB,CACpB,KAAa,EACb,OAA2C;;YAE3C,OAAO,IAAI,CAAC,OAAO,CAAC,gBAAgB,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QACvD,CAAC;KAAA;IAED;;;;OAIG;IACG,cAAc,CAAC,MAAc;;YACjC,OAAO,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;QAC7C,CAAC;KAAA;IAED;;;;;OAKG;IACG,eAAe,CAAC,EAAU,EAAE,MAAc;;YAC9C,MAAM,IAAI,CAAC,OAAO,CAAC,eAAe,CAAC,EAAE,EAAE,MAAM,CAAC,CAAC;QACjD,CAAC;KAAA;IAED;;;OAGG;IACG,gBAAgB;;YACpB,MAAM,IAAI,CAAC,OAAO,CAAC,gBAAgB,EAAE,CAAC;QACxC,CAAC;KAAA;CACF;AAlFD,wBAkFC"}

package/modules/agent/agent.ts

@@ -1,107 +0,0 @@
-import { GraphContext } from "@/types";
-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({
-      name: "assistant",
-      schema: AgentContextSchema,
-      context: {
-        input: { raw: "" },
-        actions: [],
-        response: "",
-      },
-      nodes: [
-        {
-          name: "process",
-          execute: async (context: GraphContext<typeof AgentContextSchema>) => {
-            const agentContext = context as unknown as AgentContext;
-            const decision = await this.executor.makeDecision(agentContext);
-            context.actions = decision.actions;
-            context.response = decision.response;
-          },
-          next: (context: GraphContext<typeof AgentContextSchema>) =>
-            context.actions.length > 0 ? ["execute"] : [],
-        },
-        {
-          name: "execute",
-          execute: async (context: GraphContext<typeof AgentContextSchema>) => {
-            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", {
-      input: { raw: input },
-      actions: [],
-      response: "",
-    });
-
-    return this.workflow.getContext() as unknown as AgentContext;
-  }
-}

package/modules/agent/generic-assistant.ts

@@ -1,92 +0,0 @@
-import { GraphContext } from "@/types";
-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" }
- * });
- */
-export class Agent {
-  private executor: GenericExecutor;
-  private workflow: GraphFlow<typeof AgentContextSchema>;
-
-  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();
-  }
-
-  private setupWorkflow(): GraphFlow<typeof AgentContextSchema> {
-    return new GraphFlow({
-      name: "assistant",
-      schema: AgentContextSchema,
-      context: {
-        input: { raw: "" },
-        actions: [],
-        response: "",
-        executedActions: [],
-      },
-      nodes: [
-        {
-          name: "process",
-          execute: async (context: GraphContext<typeof AgentContextSchema>) => {
-            const agentContext = context as unknown as AgentContext;
-            const decision = await this.executor.makeDecision(agentContext);
-            context.actions = decision.actions;
-            context.response = decision.response;
-          },
-          next: (context: GraphContext<typeof AgentContextSchema>) =>
-            context.actions.length > 0 ? ["execute"] : [],
-        },
-        {
-          name: "execute",
-          execute: async (context: GraphContext<typeof AgentContextSchema>) => {
-            console.log(`Executing actions:`);
-            console.log(context.actions);
-
-            await this.executor.executeActions(
-              context.actions,
-              context as unknown as AgentContext
-            );
-          },
-          next: ["process"],
-        },
-      ],
-    });
-  }
-
-  public async process(input: string): Promise<AgentContext> {
-    await this.workflow.execute("process", {
-      input: { raw: input },
-      actions: [],
-      response: "",
-    });
-
-    return this.workflow.getContext() as unknown as AgentContext;
-  }
-}

package/modules/agent/generic-executor.ts

@@ -1,252 +0,0 @@
-import chalk from "chalk";
-import { z } from "zod";
-import { GraphFlow } from "../../graph/index";
-import {
-  ActionSchema,
-  AgentContext,
-  DecisionOutput,
-  ExecutorConfig,
-} from "../../types/agent";
-import { BaseAgent } from "./base";
-import { AgentExecutor } from "./base/executor";
-import { LLMFactory } from "./llm-factory";
-import { PromptBuilder } from "./prompt-builder";
-
-/**
- * Generic executor that handles the interaction between the agent and LLM
- * Uses a structured prompt format:
- * - ROLE: The function/job the agent performs
- * - GOAL: The specific objective to achieve
- * - BACKSTORY: The personality and behavior traits
- * - CONTEXT: Current knowledge and state
- * - AVAILABLE ACTIONS: What the agent can do
- * - INSTRUCTIONS: How to process and respond
- * @class GenericExecutor
- * @extends {AgentExecutor}
- */
-export class GenericExecutor extends AgentExecutor {
-  private verbose: boolean;
-  private llm: ReturnType<typeof LLMFactory.createLLM>;
-
-  /**
-   * Creates an instance of GenericExecutor
-   * @param {BaseAgent} agent - The agent instance this executor is tied to
-   * @param {GraphFlow<any>[]} graphs - Array of available graph flows
-   * @param {ExecutorConfig} config - Configuration for the executor
-   */
-  constructor(
-    agent: BaseAgent,
-    graphs: GraphFlow<any>[],
-    config: ExecutorConfig
-  ) {
-    super(agent, graphs);
-    this.verbose = config.verbose ?? true;
-    this.llm = LLMFactory.createLLM(config.llmConfig);
-  }
-
-  /**
-   * Logs a message with a specific type if verbose mode is enabled
-   * @private
-   * @param {"info" | "success" | "warning" | "error" | "thinking"} type - The type of log message
-   * @param {string} message - The message to log
-   */
-  private log(
-    type: "info" | "success" | "warning" | "error" | "thinking",
-    message: string
-  ) {
-    if (!this.verbose) return;
-
-    const prefix = {
-      info: chalk.blue("ℹ"),
-      success: chalk.green("✓"),
-      warning: chalk.yellow("⚠"),
-      error: chalk.red("✖"),
-      thinking: chalk.magenta("🤔"),
-    }[type];
-
-    console.log(`${prefix} ${message}`);
-  }
-
-  /**
-   * Generates a string representation of the available action schemas
-   * @private
-   * @returns {string} Formatted string containing all available actions and their parameters
-   */
-  protected generateActionSchema(): string {
-    return Array.from(this.availableGraphs.values())
-      .map((graph) => {
-        const schema = graph.getSchema();
-        const schemaDescription = Object.entries(schema.shape)
-          .map(([key, value]) => {
-            const zodValue = value as z.ZodTypeAny;
-            return `    - ${key}: ${
-              zodValue.description || zodValue._def.typeName
-            }`;
-          })
-          .join("\n");
-
-        return `${graph.name}:
-  Parameters:
-${schemaDescription}
-  Available Operations:
-${graph
-  .getNodes()
-  .map((n) => `    - ${n.name}`)
-  .join("\n")}`;
-      })
-      .join("\n\n");
-  }
-
-  private async buildSystemPrompt(context: AgentContext): Promise<string> {
-    return new PromptBuilder()
-      .addSection("ROLE", this.agent.getRole())
-      .addSection("GOAL", this.agent.getGoal())
-      .addSection("BACKSTORY", this.agent.getBackstory())
-      .addSection(
-        "RECENT ACTIONS (check this before deciding what to do)",
-        context.knowledge || "None"
-      )
-      .addSection(
-        "AVAILABLE ACTIONS (only if you need)",
-        this.generateActionSchema()
-      )
-      .addSection(
-        "INSTRUCTIONS",
-        `
-- Never take actions if an recent action matches the user's input
-- If you need to take actions, structure parameters according to the action's schema
-- If goal is achieved, explain that you achieved for examples:
-  - "I have achieved the goal"
-  - "I have done what I needed to do"
-  - "I have completed the task"
-      `
-      )
-      .build(context);
-  }
-
-  /**
-   * Makes a decision based on the current context using the LLM
-   * @param {AgentContext} context - The context to base the decision on
-   * @returns {Promise<DecisionOutput>} The decision output containing actions and response
-   */
-  async makeDecision(context: AgentContext): Promise<DecisionOutput> {
-    this.log(
-      "thinking",
-      chalk.dim("Analyzing context and available actions...")
-    );
-
-    const systemPrompt = await this.buildSystemPrompt(context);
-
-    console.log({ systemPrompt });
-    this.log("info", chalk.dim("Generating response..."));
-
-    const result = await this.llm.generate(
-      {
-        system: systemPrompt,
-        user: `User sent you this message at ${new Date().toISOString()}\n${
-          context.input.raw
-        }`,
-      },
-      z.object({
-        actions: z.array(
-          z.object({
-            name: z.string(),
-            parameters: z.array(
-              z.object({
-                name: z.string(),
-                value: z.any(),
-              })
-            ),
-          })
-        ),
-        response: z.string(),
-      })
-    );
-    if (result.object.actions.length > 0) {
-      this.log("success", chalk.green("Decided to take actions:"));
-      result.object.actions.forEach(
-        (action: {
-          name: string;
-          parameters: Array<{ name: string; value: any }>;
-        }) => {
-          this.log("info", chalk.cyan(`Action: ${action.name}`));
-          action.parameters.forEach((param: { name: string; value: any }) => {
-            this.log(
-              "info",
-              chalk.dim(`  - ${param.name}: ${JSON.stringify(param.value)}`)
-            );
-          });
-        }
-      );
-    } else {
-      this.log("info", chalk.yellow("No actions needed"));
-    }
-
-    this.log("success", chalk.green(`Response: ${result.object.response}`));
-
-    return {
-      actions: result.object.actions as unknown as ActionSchema[],
-      response: result.object.response,
-    };
-  }
-
-  /**
-   * Executes multiple workflows with their respective inputs
-   * @protected
-   * @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 async executeWorkflows(
-    workflows: GraphFlow<any>[],
-    startNodes: string[],
-    inputs: any[],
-    context: AgentContext
-  ): Promise<void> {
-    this.log("info", chalk.cyan("Executing workflows:"));
-
-    for (let i = 0; i < workflows.length; i++) {
-      const workflow = workflows[i];
-      const startNode = startNodes[i];
-      const input = inputs[i];
-
-      this.log(
-        "info",
-        chalk.dim(
-          `Executing workflow ${workflow.name} starting at node ${startNode}`
-        )
-      );
-      this.log(
-        "info",
-        chalk.dim(`Input parameters: ${JSON.stringify(input, null, 2)}`)
-      );
-
-      // Initialize workflow context with input
-      const workflowContext = {
-        ...workflow.getContext(),
-        ...input,
-      };
-
-      // Execute with merged context
-      const result = await workflow.execute(
-        startNode,
-
-        workflowContext
-      );
-
-      this.log("success", chalk.green(`Workflow ${workflow.name} completed`));
-      this.log("info", chalk.dim(`Result: ${JSON.stringify(result, null, 2)}`));
-
-      if (context.executedActions) {
-        context.executedActions.push({
-          name: workflow.name,
-          result: result,
-          timestamp: new Date().toISOString(),
-          isExecuted: true,
-        });
-      }
-    }
-  }
-}

package/modules/agent/llm-factory.ts

@@ -1,47 +0,0 @@
-import { LLMConfig, PromptInput } from "@/types/agent";
-import { openai } from "@ai-sdk/openai";
-import { generateObject } from "ai";
-import { z } from "zod";
-
-/**
- * Factory class for creating Language Model instances based on configuration
- * @class LLMFactory
- */
-export class LLMFactory {
-  /**
-   * Creates an LLM instance based on the provided configuration
-   * @static
-   * @param {LLMConfig} config - Configuration for the LLM
-   * @returns {Object} An object with a generate method for interacting with the LLM
-   * @throws {Error} When an unsupported provider is specified or custom provider lacks required function
-   */
-  static createLLM(config: LLMConfig) {
-    switch (config.provider) {
-      case "openai":
-        return {
-          generate: async (
-            prompt: string | PromptInput,
-            schema: z.ZodType<any>
-          ) => {
-            return generateObject({
-              model: openai(config.model),
-              temperature: config.temperature ?? 0.7,
-              maxTokens: config.maxTokens,
-              prompt: typeof prompt === "string" ? prompt : prompt.user,
-              system: typeof prompt === "string" ? undefined : prompt.system,
-              schema,
-            });
-          },
-        };
-      case "custom":
-        if (!config.customCall) {
-          throw new Error("Custom LLM provider requires a customCall function");
-        }
-        return {
-          generate: config.customCall,
-        };
-      default:
-        throw new Error(`Unsupported LLM provider: ${config.provider}`);
-    }
-  }
-}