@ai.ntellect/core 0.3.1 → 0.4.0

package/dist/llm/evaluator/index.js

@@ -1,151 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Evaluator = void 0;
-const openai_1 = require("@ai-sdk/openai");
-const ai_1 = require("ai");
-const zod_1 = require("zod");
-const types_1 = require("../../types");
-const inject_actions_1 = require("../../utils/inject-actions");
-const context_1 = require("./context");
-class Evaluator {
-    constructor(tools, memory, interpreters) {
-        this.model = (0, openai_1.openai)("gpt-4o");
-        this.tools = tools;
-        this.memory = memory;
-        this.interpreters = interpreters;
-    }
-    composeContext(state) {
-        const { userRequest, results } = state;
-        const { role, language, guidelines } = context_1.evaluatorContext.behavior;
-        const { important, warnings } = guidelines;
-        const context = `
-      # ROLE: ${role}
-      # LANGUAGE: ${language}
-      # IMPORTANT: ${important.join("\n")}
-      # NEVER: ${warnings.join("\n")}
-      # USER_REQUEST: ${userRequest}
-      # ACTIONS AVAILABLE: ${(0, inject_actions_1.injectActions)(this.tools)}
-      # CURRENT_RESULTS: ${results}
-      # INTERPRETERS: ${this.interpreters
-            .map((interpreter) => interpreter.name)
-            .join(", ")}
-    `;
-        return context;
-    }
-    async process(prompt, results) {
-        try {
-            const context = this.composeContext({
-                userRequest: prompt,
-                results: results,
-            });
-            console.log("\n🔍 Evaluator processing");
-            console.log("Goal:", prompt);
-            const response = await (0, ai_1.generateObject)({
-                model: this.model,
-                schema: zod_1.z.object({
-                    actionsCompleted: zod_1.z.array(zod_1.z.string()),
-                    actionsFailed: zod_1.z.array(zod_1.z.string()),
-                    extraInformationsToStore: zod_1.z.array(zod_1.z.object({
-                        memoryType: zod_1.z.enum(["episodic", "semantic", "procedural"]),
-                        queryForData: zod_1.z.string(),
-                        data: zod_1.z.string(),
-                        tags: zod_1.z.array(zod_1.z.string()),
-                    })),
-                    response: zod_1.z.string(),
-                    isNextActionNeeded: zod_1.z.boolean(),
-                    nextActionsNeeded: zod_1.z.array(zod_1.z.object({
-                        name: zod_1.z.string(),
-                        parameters: zod_1.z.array(zod_1.z.object({
-                            name: zod_1.z.string(),
-                            value: zod_1.z.any(),
-                        })),
-                    })),
-                    why: zod_1.z.string(),
-                    interpreter: zod_1.z.string(),
-                }),
-                prompt: prompt,
-                system: `${context}`,
-                temperature: 0,
-            });
-            const validatedResponse = {
-                ...response.object,
-                nextActionsNeeded: response.object.nextActionsNeeded.map((action) => ({
-                    ...action,
-                    parameters: action.parameters || {},
-                })),
-            };
-            if (validatedResponse.extraInformationsToStore.length > 0) {
-                console.log("\n💭 Processing important memories to store", validatedResponse);
-                for (const item of validatedResponse.extraInformationsToStore) {
-                    console.log("\n📝 Processing memory item:");
-                    console.log("Type:", item.memoryType);
-                    console.log("Content:", item.queryForData);
-                    const memories = await this.memory.persistent.searchSimilarQueries(item.queryForData, {
-                        similarityThreshold: 70,
-                    });
-                    if (memories.length > 0) {
-                        console.log("🔄 Similar memory already exists - skipping");
-                        continue;
-                    }
-                    console.log("✨ Storing new memory");
-                    await this.memory.persistent.createMemory({
-                        id: crypto.randomUUID(),
-                        purpose: item.memoryType,
-                        query: item.queryForData,
-                        data: item.data,
-                        scope: types_1.MemoryScope.GLOBAL,
-                        createdAt: new Date(),
-                    });
-                }
-            }
-            // Storing workflow actions completed
-            const cacheMemory = this.memory.cache;
-            if (cacheMemory) {
-                cacheMemory.createMemory({
-                    content: prompt,
-                    type: types_1.MemoryType.ACTION,
-                    data: validatedResponse.actionsCompleted,
-                    scope: types_1.MemoryScope.GLOBAL,
-                });
-                console.log("✅ Workflow actions completed stored in cache", prompt, validatedResponse.actionsCompleted);
-            }
-            console.log("\n✅ Evaluation completed");
-            console.log("─".repeat(50));
-            console.log("Results:", JSON.stringify(validatedResponse, null, 2));
-            return validatedResponse;
-        }
-        catch (error) {
-            console.error("\n❌ Evaluator error:", error.message);
-            if (error) {
-                console.log("Evaluator error");
-                console.dir(error.value, { depth: null });
-                console.error(error.message);
-                if (error.value.extraInformationsToStore.length > 0) {
-                    for (const item of error.value.extraInformationsToStore) {
-                        // Check if the item is already in the memory
-                        const memories = await this.memory.persistent.searchSimilarQueries(item.content);
-                        if (memories.length === 0) {
-                            console.log("Adding to memory", {
-                                query: item.content,
-                                data: item.data,
-                            });
-                            await this.memory.persistent.createMemory({
-                                id: crypto.randomUUID(),
-                                purpose: "importantToRemember",
-                                query: item.content,
-                                data: item.data,
-                                scope: types_1.MemoryScope.USER,
-                                createdAt: new Date(),
-                            });
-                        }
-                    }
-                }
-                return {
-                    ...error.value,
-                };
-            }
-            // throw error;
-        }
-    }
-}
-exports.Evaluator = Evaluator;

package/llm/evaluator/context.ts

@@ -1,21 +0,0 @@
-export const evaluatorContext = {
-  behavior: {
-    language: "same_as_user",
-    role: "Your role is to ensure the goal will be achieved and make a response or suggest next actions.",
-    guidelines: {
-      important: [
-        "Verify if all actions were executed successfully (actionsAlreadyDone).",
-        "Check if the results align with the initial goal (explain in 'why' field).",
-        "Suggest next actions in 'nextActionsNeeded' if the goal is not achieved and if actions in 'actionsAlreadyDone' are not enough.",
-        "If you retrieved the informations from your internal knowledge base, no need to store them in 'extraInformationsToStore'.",
-        "Store ONLY new needed informations in 'extraInformationsToStore'.",
-        "Choose the most relevant informations and memory type: episodic, semantic, or procedural.",
-      ],
-      warnings: [
-        "NEVER store an old data you retrieve from your internal knowledge base.",
-        "NEVER make assumptions about missing data.",
-        "NEVER repeat actions already completed unless explicitly required.",
-      ],
-    },
-  },
-};

package/llm/evaluator/index.ts

@@ -1,194 +0,0 @@
-import { openai } from "@ai-sdk/openai";
-import { generateObject } from "ai";
-import { z } from "zod";
-import { CacheMemory } from "../../memory/cache";
-import { PersistentMemory } from "../../memory/persistent";
-import { ActionSchema, MemoryScope, MemoryType, State } from "../../types";
-import { injectActions } from "../../utils/inject-actions";
-import { Interpreter } from "../interpreter";
-import { evaluatorContext } from "./context";
-
-export class Evaluator {
-  private readonly model = openai("gpt-4o");
-  public tools: ActionSchema[];
-  private memory: {
-    persistent: PersistentMemory;
-    cache?: CacheMemory;
-  };
-  private interpreters: Interpreter[];
-
-  constructor(
-    tools: ActionSchema[],
-    memory: {
-      persistent: PersistentMemory;
-      cache?: CacheMemory;
-    },
-    interpreters: Interpreter[]
-  ) {
-    this.tools = tools;
-    this.memory = memory;
-    this.interpreters = interpreters;
-  }
-
-  composeContext(state: State) {
-    const { userRequest, results } = state;
-    const { role, language, guidelines } = evaluatorContext.behavior;
-    const { important, warnings } = guidelines;
-
-    const context = `
-      # ROLE: ${role}
-      # LANGUAGE: ${language}
-      # IMPORTANT: ${important.join("\n")}
-      # NEVER: ${warnings.join("\n")}
-      # USER_REQUEST: ${userRequest}
-      # ACTIONS AVAILABLE: ${injectActions(this.tools)}
-      # CURRENT_RESULTS: ${results}
-      # INTERPRETERS: ${this.interpreters
-        .map((interpreter) => interpreter.name)
-        .join(", ")}
-    `;
-    return context;
-  }
-
-  async process(prompt: string, results: string): Promise<any> {
-    try {
-      const context = this.composeContext({
-        userRequest: prompt,
-        results: results,
-      });
-      console.log("\n🔍 Evaluator processing");
-      console.log("Goal:", prompt);
-
-      const response = await generateObject({
-        model: this.model,
-        schema: z.object({
-          requestLanguage: z.string(),
-          actionsAlreadyDone: z.array(z.string()),
-          extraInformationsToStore: z.array(
-            z.object({
-              memoryType: z.enum(["episodic", "semantic", "procedural"]),
-              queryForData: z.string(),
-              data: z.string(),
-              tags: z.array(z.string()),
-            })
-          ),
-          response: z.string(),
-          isNextActionNeeded: z.boolean(),
-          nextActionsNeeded: z.array(
-            z.object({
-              name: z.string(),
-              parameters: z.array(
-                z.object({
-                  name: z.string(),
-                  value: z.any(),
-                })
-              ),
-            })
-          ),
-          why: z.string(),
-          interpreter: z.string(),
-        }),
-        prompt: prompt,
-        system: `${context}`,
-        temperature: 0,
-      });
-
-      const validatedResponse = {
-        ...response.object,
-        nextActionsNeeded: response.object.nextActionsNeeded.map((action) => ({
-          ...action,
-          parameters: action.parameters || {},
-        })),
-      };
-
-      if (validatedResponse.extraInformationsToStore.length > 0) {
-        console.log(
-          "\n💭 Processing important memories to store",
-          validatedResponse
-        );
-        for (const item of validatedResponse.extraInformationsToStore) {
-          console.log("\n📝 Processing memory item:");
-          console.log("Type:", item.memoryType);
-          console.log("Content:", item.queryForData);
-
-          const memories = await this.memory.persistent.findRelevantDocuments(
-            item.queryForData,
-            {
-              similarityThreshold: 70,
-            }
-          );
-
-          if (memories.length > 0) {
-            console.log("🔄 Similar memory already exists - skipping");
-            continue;
-          }
-
-          console.log("✨ Storing new memory");
-          await this.memory.persistent.createMemory({
-            id: crypto.randomUUID(),
-            purpose: item.memoryType,
-            query: item.queryForData,
-            data: item.data,
-            scope: MemoryScope.GLOBAL,
-            createdAt: new Date(),
-          });
-        }
-      }
-
-      // Storing workflow actions completed
-      const cacheMemory = this.memory.cache;
-      if (cacheMemory) {
-        cacheMemory.createMemory({
-          content: prompt,
-          type: MemoryType.ACTION,
-          data: validatedResponse.actionsAlreadyDone,
-          scope: MemoryScope.GLOBAL,
-        });
-        console.log(
-          "✅ Workflow actions completed stored in cache",
-          prompt,
-          validatedResponse.actionsAlreadyDone
-        );
-      }
-      console.log("\n✅ Evaluation completed");
-      console.log("─".repeat(50));
-      console.log("Results:", JSON.stringify(validatedResponse, null, 2));
-
-      return validatedResponse;
-    } catch (error: any) {
-      console.error("\n❌ Evaluator error:", error.message);
-      if (error) {
-        console.log("Evaluator error");
-        console.dir(error.value, { depth: null });
-        console.error(error.message);
-        if (error.value.extraInformationsToStore.length > 0) {
-          for (const item of error.value.extraInformationsToStore) {
-            // Check if the item is already in the memory
-            const memories = await this.memory.persistent.findRelevantDocuments(
-              item.content
-            );
-            if (memories.length === 0) {
-              console.log("Adding to memory", {
-                query: item.content,
-                data: item.data,
-              });
-              await this.memory.persistent.createMemory({
-                id: crypto.randomUUID(),
-                purpose: "importantToRemember",
-                query: item.content,
-                data: item.data,
-                scope: MemoryScope.GLOBAL,
-                createdAt: new Date(),
-              });
-            }
-          }
-        }
-
-        return {
-          ...error.value,
-        };
-      }
-      // throw error;
-    }
-  }
-}