@ai.ntellect/core 0.4.1 → 0.6.0

package/llm/memory-manager/context.ts

@@ -1,21 +0,0 @@
-import { Character } from "../interpreter/context";
-
-export const memoryManagerInstructions: Character = {
-  role: "You are the memory curator. Your role is to extract and format memories from interactions.",
-  language: "user_request",
-  guidelines: {
-    important: [
-      "Generate memories based on the user request",
-      "Generate query for requested data as the user could ask for it later",
-      "Should be short-term memories only if it's ephemeral but relevant and reusable",
-      "Only store as long-term: User information, User preferences, Important facts that don't change often, Historical milestones",
-      "Make memory data concise and clear",
-      "Set appropriate TTL based on data volatility",
-    ],
-    warnings: [
-      "Never store data that is not provided by the results",
-      "Never store data that is not relevant to the user request",
-    ],
-  },
-  examplesMessages: [],
-};

package/llm/memory-manager/index.ts

@@ -1,163 +0,0 @@
-import { LanguageModelV1 } from "ai";
-import { z } from "zod";
-import { CacheMemory } from "../../memory/cache";
-import { PersistentMemory } from "../../memory/persistent";
-import { MemoryScope } from "../../types";
-import { generateObject } from "../../utils/generate-object";
-import { LLMHeaderBuilder } from "../../utils/header-builder";
-import { State } from "../orchestrator/types";
-import { memoryManagerInstructions } from "./context";
-
-interface MemoryResponse {
-  memories: Array<{
-    data: string;
-    type: "short-term" | "long-term";
-    category:
-      | "user_information"
-      | "user_preference"
-      | "task"
-      | "current_goal"
-      | "news"
-      | "fact"
-      | "other";
-    queryForMemory: string;
-    tags: string[];
-    ttl: number;
-  }>;
-}
-export class MemoryManager {
-  private readonly model: LanguageModelV1;
-  private readonly memory?: {
-    cache?: CacheMemory;
-    persistent?: PersistentMemory;
-  };
-
-  constructor(config: {
-    model: LanguageModelV1;
-    memory?: {
-      cache?: CacheMemory;
-      persistent?: PersistentMemory;
-    };
-  }) {
-    this.model = config.model;
-    this.memory = config.memory;
-  }
-
-  buildContext(state: State) {
-    const context = LLMHeaderBuilder.create()
-      .addHeader("ROLE", memoryManagerInstructions.role)
-      .addHeader("LANGUAGE", memoryManagerInstructions.language)
-      .addHeader("IMPORTANT", memoryManagerInstructions.guidelines.important)
-      .addHeader("WARNINGS", memoryManagerInstructions.guidelines.warnings)
-      .addHeader("CURRENT_CONTEXT", state.currentContext)
-      .addHeader("RESULTS", JSON.stringify(state.results));
-    return context.toString();
-  }
-
-  async process(state: State, result: string) {
-    const context = this.buildContext(state);
-
-    const memories = await generateObject<MemoryResponse>({
-      model: this.model,
-      schema: z.object({
-        memories: z.array(
-          z.object({
-            data: z.string(),
-            type: z.enum(["short-term", "long-term"]),
-            category: z.enum([
-              "user_information",
-              "user_preference",
-              "task",
-              "current_goal",
-              "news",
-              "fact",
-              "other",
-            ]),
-            queryForData: z.string(),
-            tags: z.array(z.string()),
-            ttl: z.number(),
-          })
-        ),
-      }),
-      prompt: state.currentContext,
-      system: context.toString(),
-      temperature: 1,
-    });
-
-    console.log("Memories:", memories.object.memories);
-
-    if (!this.memory) {
-      return;
-    }
-
-    // Store memories after all processing is complete
-    await Promise.all([
-      // Store short-term memories in cache
-      ...memories.object.memories
-        .filter((m: any) => m.type === "short-term")
-        .map(async (memoryItem: any) => {
-          if (!this.memory?.cache) {
-            return;
-          }
-
-          const existingCacheMemories =
-            await this.memory.cache.findSimilarActions(memoryItem.data, {
-              similarityThreshold: 85,
-              maxResults: 3,
-              scope: MemoryScope.GLOBAL,
-            });
-
-          if (existingCacheMemories.length > 0) {
-            console.log(
-              "⚠️ Similar memory already exists in cache:",
-              memoryItem.data
-            );
-            return;
-          }
-
-          await this.memory.cache.createMemory({
-            query: memoryItem.queryForMemory,
-            data: memoryItem.data,
-            ttl: memoryItem.ttl, // Use TTL from LLM
-          });
-          console.log("✅ Memory stored in cache:", memoryItem.data);
-        }),
-
-      // Store long-term memories in persistent storage
-      ...memories.object.memories
-        .filter((m) => m.type === "long-term")
-        .map(async (memoryItem) => {
-          if (!this.memory?.persistent) {
-            return;
-          }
-
-          const existingPersistentMemories =
-            await this.memory.persistent.findRelevantDocuments(
-              memoryItem.data,
-              {
-                similarityThreshold: 85,
-              }
-            );
-
-          if (existingPersistentMemories.length > 0) {
-            console.log(
-              "⚠️ Similar memory already exists in persistent storage:",
-              memoryItem.data
-            );
-            return;
-          }
-
-          await this.memory.persistent.createMemory({
-            query: memoryItem.queryForMemory,
-            data: memoryItem.data,
-            category: memoryItem.category,
-            tags: memoryItem.tags,
-            roomId: "global",
-            createdAt: new Date(),
-            id: crypto.randomUUID(),
-          });
-          console.log("✅ Memory stored in persistent storage:", memoryItem);
-        }),
-    ]);
-  }
-}

package/llm/orchestrator/context.ts

@@ -1,22 +0,0 @@
-import { Character } from "../interpreter/context";
-
-export const orchestratorInstructions: Character = {
-  role: "You are the orchestrator. Your role is to evaluate the current state and determine next actions.",
-  language: "user_request",
-  guidelines: {
-    important: [
-      "Continue executing actions until ALL necessary goals are achieved",
-      "You can schedule actions in cron expression to be executed later (if needed)",
-      "Only stop when you have a complete picture of the goal",
-      "Social responses can be partial while gathering more data",
-      "Set shouldContinue to false if no more actions are needed",
-      "Once all actions are completed, choose the right interpreter to interpret the results",
-    ],
-    warnings: [
-      "Never use a tool if it's not related to the user request",
-      "Never schedule actions that are not related to the user request",
-      "Never repeat the same action if it's not required to achieve the goal",
-      "Never repeat scheduled actions if not required to achieve the goal",
-    ],
-  },
-};

package/llm/orchestrator/index.ts

@@ -1,232 +0,0 @@
-import { LanguageModelV1 } from "ai";
-import { z } from "zod";
-import { CacheMemory } from "../../memory/cache";
-import { PersistentMemory } from "../../memory/persistent";
-import { ActionQueueManager } from "../../services/queue";
-import { CacheConfig, RedisCache } from "../../services/redis-cache";
-import { TaskScheduler } from "../../services/scheduler";
-import {
-  ActionSchema,
-  GenerateObjectResponse,
-  MemoryScope,
-  QueueCallbacks,
-} from "../../types";
-import { generateObject } from "../../utils/generate-object";
-import { LLMHeaderBuilder } from "../../utils/header-builder";
-import { injectActions } from "../../utils/inject-actions";
-import { Interpreter } from "../interpreter";
-import { orchestratorInstructions } from "./context";
-import { State } from "./types";
-
-export class AgentRuntime {
-  private readonly model: LanguageModelV1;
-  private readonly tools: ActionSchema[];
-  private readonly interpreters: Interpreter[];
-  private readonly queueManager: ActionQueueManager;
-  private readonly scheduler: TaskScheduler;
-  private readonly cache: RedisCache;
-  private memory?: {
-    persistent?: PersistentMemory;
-    cache?: CacheMemory;
-  };
-
-  constructor(
-    model: LanguageModelV1,
-    tools: ActionSchema[],
-    interpreters: Interpreter[],
-    redisConfig: CacheConfig,
-    memory?: {
-      persistent?: PersistentMemory;
-      cache?: CacheMemory;
-    },
-    callbacks?: QueueCallbacks
-  ) {
-    this.model = model;
-    this.tools = tools;
-    this.interpreters = interpreters;
-    this.queueManager = new ActionQueueManager(tools, callbacks);
-    this.memory = memory;
-    this.cache = new RedisCache(redisConfig);
-    this.scheduler = new TaskScheduler(this, this.cache);
-  }
-
-  private async buildContext(state: State): Promise<string> {
-    console.log("🧠 Building context with RAG and CAG...");
-    const context = LLMHeaderBuilder.create();
-
-    // Add orchestrator instructions
-    context.addHeader("ROLE", orchestratorInstructions.role);
-    context.addHeader("LANGUAGE", orchestratorInstructions.language);
-    context.addHeader(
-      "IMPORTANT",
-      orchestratorInstructions.guidelines.important
-    );
-    context.addHeader("WARNINGS", orchestratorInstructions.guidelines.warnings);
-    // Add tools to context
-    context.addHeader("TOOLS", injectActions(this.tools));
-
-    // Add previous actions if any
-    if (state.previousActions?.length) {
-      context.addHeader(
-        "PREVIOUS_ACTIONS",
-        JSON.stringify(state.previousActions)
-      );
-    }
-
-    // Get recent similar actions (CAG)
-    if (this.memory?.cache) {
-      const cacheMemories = await this.memory.cache.findSimilarActions(
-        state.currentContext,
-        {
-          similarityThreshold: 80,
-          maxResults: 3,
-          scope: MemoryScope.GLOBAL,
-        }
-      );
-
-      if (cacheMemories.length > 0) {
-        context.addHeader("RECENT_ACTIONS", JSON.stringify(cacheMemories));
-      }
-    }
-
-    // Get relevant knowledge (RAG)
-    if (this.memory?.persistent) {
-      const persistentMemory =
-        await this.memory.persistent.findRelevantDocuments(
-          state.currentContext,
-          {
-            similarityThreshold: 80,
-          }
-        );
-
-      if (persistentMemory.length > 0) {
-        context.addHeader(
-          "RELEVANT_KNOWLEDGE",
-          JSON.stringify(persistentMemory)
-        );
-      }
-    }
-
-    // Add available interpreters
-    context.addHeader(
-      "AVAILABLE_INTERPRETERS",
-      JSON.stringify(this.interpreters.map((i) => i.name))
-    );
-    console.log("Context built with memories", context.toString());
-    return context.toString();
-  }
-
-  async process(state: State): Promise<{
-    shouldContinue: boolean;
-    actions: Array<{
-      name: string;
-      parameters: Array<{
-        name: string;
-        value: any;
-      }>;
-      scheduler?: {
-        isScheduled: boolean;
-        scheduledAtInC?: string;
-        interval?: string;
-        reason?: string;
-      };
-    }>;
-    socialResponse?: {
-      shouldRespond: boolean;
-      response?: string;
-      isPartialResponse?: boolean;
-    };
-    interpreter?: string;
-    results?: string;
-  }> {
-    console.log("🔄 Processing state:");
-    console.dir(state, { depth: null });
-    if (state.previousActions?.length) {
-      console.log(
-        "📊 Previous actions:",
-        state.previousActions
-          .map((a) => (typeof a === "string" ? a : a.name))
-          .join(", ")
-      );
-    }
-
-    const context = await this.buildContext(state);
-
-    console.log("\n🧠 Generating response from LLM...");
-    const response = await generateObject<GenerateObjectResponse>({
-      model: this.model,
-      schema: z.object({
-        shouldContinue: z.boolean(),
-        actions: z.array(
-          z.object({
-            name: z.string(),
-            parameters: z.array(
-              z.object({
-                name: z.string(),
-                value: z.any(),
-              })
-            ),
-            scheduler: z
-              .object({
-                isScheduled: z.boolean(),
-                cronExpression: z.string().optional(),
-                reason: z.string().optional(),
-              })
-              .optional(),
-          })
-        ),
-        socialResponse: z
-          .object({
-            shouldRespond: z.boolean(),
-            response: z.string().optional(),
-            isPartialResponse: z.boolean().optional(),
-          })
-          .optional(),
-        interpreter: z.string().optional(),
-      }),
-      prompt: state.currentContext,
-      system: context.toString(),
-      temperature: 0,
-    });
-    console.log("🔄 Orchestrator response:");
-    console.dir(response.object, { depth: null });
-
-    // Force shouldContinue to false if no actions are planned
-    if (response.object.actions.length === 0) {
-      response.object.shouldContinue = false;
-      console.log("⚠️ No actions planned, forcing shouldContinue to false");
-    }
-
-    // Handle social interactions and actions in a single block
-    if (response.object.socialResponse?.shouldRespond) {
-      console.log("\n💬 Processing social response");
-      if (response.object.socialResponse.response) {
-        console.log("📢 Response:", response.object.socialResponse.response);
-        // Ensure all parameters have a value property
-      }
-    }
-
-    // Handle scheduled actions
-    for (const action of response.object.actions) {
-      if (action.scheduler?.isScheduled) {
-        await this.scheduler.scheduleRequest({
-          originalRequest: state.currentContext,
-          cronExpression: action.scheduler.cronExpression,
-        });
-      }
-    }
-
-    // Store actions in Redis cache
-    if (response.object.actions.length > 0) {
-      const requestId = crypto.randomUUID();
-      await this.cache.storePreviousActions(requestId, response.object.actions);
-    }
-
-    // Store message in recent messages
-    await this.cache.storeRecentMessage(state.currentContext, {
-      socialResponse: response.object.socialResponse,
-    });
-
-    return response.object;
-  }
-}

package/llm/orchestrator/types.ts

@@ -1,14 +0,0 @@
-import { QueueResult } from "../../types";
-
-export interface State {
-  currentContext: string;
-  previousActions: (string | QueueResult)[];
-  reward?: number;
-  userRequest?: string;
-  results?: string;
-}
-
-export interface Action {
-  name: string;
-  parameters: Record<string, any>;
-}

package/memory/cache.ts

@@ -1,221 +0,0 @@
-import { openai } from "@ai-sdk/openai";
-import { cosineSimilarity, embed, EmbeddingModel } from "ai";
-import { createClient } from "redis";
-import {
-  CacheMemoryOptions,
-  CacheMemoryType,
-  CreateMemoryInput,
-  MatchOptions,
-  MemoryScope,
-} from "../types";
-
-export class CacheMemory {
-  private redis;
-  private readonly CACHE_PREFIX: string;
-  private readonly CACHE_TTL: number;
-  private readonly embeddingModel: EmbeddingModel<string>;
-
-  constructor(options: CacheMemoryOptions) {
-    this.embeddingModel = options.embeddingModel;
-    const ttlInHours = options.cacheTTL ?? 1;
-    this.CACHE_TTL = ttlInHours * 60 * 60;
-    this.CACHE_PREFIX = options.cachePrefix ?? "memory:";
-
-    this.redis = createClient({
-      url: options.redisUrl || process.env.REDIS_URL,
-      socket: {
-        tls: true,
-        rejectUnauthorized: true,
-      },
-    });
-    this.initRedis();
-  }
-
-  private async initRedis() {
-    this.redis.on("error", (err) => {
-      console.error("❌ Redis Client Error:", err);
-    });
-
-    try {
-      await this.redis.connect();
-      console.log("✅ Successfully connected to Redis");
-    } catch (error) {
-      console.error("❌ Failed to connect to Redis:", error);
-    }
-  }
-
-  private async storeMemory(memory: CacheMemoryType, ttl?: number) {
-    const prefix = this.CACHE_PREFIX;
-    const key = `${prefix}${memory.id}`;
-    const result = await this.redis.set(key, JSON.stringify(memory), {
-      EX: ttl || this.CACHE_TTL,
-    });
-    console.log("💾 Cache memory created:", result);
-  }
-
-  async findSimilarActions(
-    query: string,
-    options: MatchOptions & { userId?: string; scope?: MemoryScope } = {}
-  ): Promise<
-    {
-      data: any;
-      query: string;
-      createdAt: Date;
-    }[]
-  > {
-    console.log("\n🔍 Searching in cache");
-    console.log("Query:", query);
-    console.log("Options:", JSON.stringify(options, null, 2));
-
-    const { embedding } = await embed({
-      model: openai.embedding("text-embedding-3-small"),
-      value: query,
-    });
-
-    const memories = await this.getAllMemories();
-    console.log(`\n📚 Found ${memories.length} cached queries to compare`);
-
-    const matches = memories
-      .map((memory) => {
-        const similarity = cosineSimilarity(embedding, memory.embedding);
-        const similarityPercentage = (similarity + 1) * 50;
-        return {
-          data: memory.data,
-          query: memory.query,
-          similarityPercentage,
-          createdAt: memory.createdAt,
-        };
-      })
-      .filter(
-        (match) =>
-          match.similarityPercentage >= (options.similarityThreshold ?? 70)
-      )
-      .sort((a, b) => b.similarityPercentage - a.similarityPercentage);
-
-    const results = options.maxResults
-      ? matches.slice(0, options.maxResults)
-      : matches;
-
-    if (results.length > 0) {
-      console.log("\n✨ Similar queries found:");
-      console.log("─".repeat(50));
-
-      results.forEach((match, index) => {
-        console.log(`\n${index + 1}. Match Details:`);
-        console.log(`   Query: ${match.query}`);
-        console.log(`   Data: ${JSON.stringify(match.data)}`);
-        console.log(`   Similarity: ${match.similarityPercentage.toFixed(2)}%`);
-        console.log("─".repeat(50));
-      });
-    } else {
-      console.log("\n❌ No similar queries found in cache");
-    }
-
-    return results.map((match) => {
-      return {
-        data: match.data,
-        query: match.query,
-        createdAt: match.createdAt,
-      };
-    });
-  }
-
-  async getAllMemories(): Promise<CacheMemoryType[]> {
-    const keys = await this.redis.keys(`${this.CACHE_PREFIX}*`);
-    const memories = await this.getMemoriesFromKeys(keys);
-
-    return memories;
-  }
-
-  private async getMemoriesFromKeys(
-    keys: string[]
-  ): Promise<CacheMemoryType[]> {
-    const memories: CacheMemoryType[] = [];
-    for (const key of keys) {
-      const data = await this.redis.get(key);
-      if (data) {
-        memories.push(JSON.parse(data));
-      }
-    }
-    return memories;
-  }
-
-  public async createMemory(
-    input: CreateMemoryInput
-  ): Promise<CacheMemoryType | undefined> {
-    console.log("\n📝 Processing new memory creation");
-    console.log("Content:", input.query);
-    console.log("TTL:", input.ttl ? `${input.ttl} seconds` : "default");
-
-    const existingPattern = await this.findSimilarActions(input.query, {
-      similarityThreshold: 95,
-      userId: input.userId,
-      scope: input.scope,
-    });
-
-    if (existingPattern.length > 0) {
-      console.log("\n🔄 Similar cache memory already exists");
-      console.log("─".repeat(50));
-      existingPattern.forEach((match, index) => {
-        console.log(`\n${index + 1}. Existing Match:`);
-        console.log(`   Query: ${match.query}`);
-        console.log(`   Data: ${JSON.stringify(match.data)}`);
-        console.log(`   Created At: ${match.createdAt}`);
-      });
-      console.log("\n⏭️  Skipping creation of new memory");
-      return;
-    }
-
-    console.log("\n🆕 No similar memory found - creating new one");
-
-    const memory = await this.createSingleMemory({
-      id: crypto.randomUUID(),
-      query: input.query,
-      data: input.data,
-      userId: input.userId,
-      scope: input.scope,
-      ttl: input.ttl,
-    });
-
-    return memory;
-  }
-
-  private async createSingleMemory(params: {
-    id: string;
-    query: string;
-    data: any;
-    userId?: string;
-    scope?: MemoryScope;
-    ttl?: number;
-  }): Promise<CacheMemoryType> {
-    console.log("\n🏗️  Creating new cache memory");
-    console.log("ID:", params.id);
-    console.log("Content:", params.query);
-
-    console.log("\n🧮 Generating embedding...");
-    const { embedding } = await embed({
-      model: this.embeddingModel,
-      value: params.query,
-    });
-    console.log("✅ Embedding generated successfully");
-
-    const memory: CacheMemoryType = {
-      id: params.id,
-      data: params.data,
-      query: params.query,
-      embedding,
-      userId: params.userId,
-      scope:
-        params.scope || (params.userId ? MemoryScope.USER : MemoryScope.GLOBAL),
-      createdAt: new Date(),
-    };
-
-    await this.storeMemory(memory, params.ttl);
-    console.log("✅ Short-term memory created and stored successfully", {
-      ...memory,
-      ttl: params.ttl || this.CACHE_TTL,
-    });
-
-    return memory;
-  }
-}