@ai.ntellect/core 0.3.1 → 0.4.0

package/llm/memory-manager/context.ts

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,163 @@
+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,15 +1,22 @@
-export const orchestratorContext = {
-  behavior: {
-    language: "same_as_user",
-    role: "Your role is to determine what actions are needed to achieve the user goal.",
-    guidelines: {
-      important: [
-        "If there is no action to do, you must answer in the 'answer' field.",
-        "If some parameters are not clear or missing, don't add the action, YOU MUST ask the user for them.",
-        "For QUESTIONS or ANALYSIS, search first in your internal knowledge base before using actions.",
-        "For ON-CHAIN actions, just use the useful actions.",
-      ],
-      warnings: ["NEVER repeat same actions if the user doesn't ask for it."],
-    },
+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,152 +1,232 @@
-import { openai } from "@ai-sdk/openai";
-import { generateObject } from "ai";
+import { LanguageModelV1 } from "ai";
 import { z } from "zod";
 import { CacheMemory } from "../../memory/cache";
 import { PersistentMemory } from "../../memory/persistent";
-import { ActionSchema, State } from "../../types";
+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 { orchestratorContext } from "./context";
-
-export class Orchestrator {
-  private readonly model = openai("gpt-4o");
-  public tools: ActionSchema[];
-  private memory: {
-    persistent: PersistentMemory;
-    cache: CacheMemory;
+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;
   };
-  private id: string;
-
-  constructor({
-    id,
-    tools,
-    memory,
-  }: {
-    id: string;
-    tools: ActionSchema[];
-    memory: {
-      persistent: PersistentMemory;
-      cache: CacheMemory;
-    };
-  }) {
-    this.id = id;
+
+  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.tools = [
-      ...tools,
-      {
-        name: "search_internal_knowledge_base",
-        description:
-          "Search for relevant information in the internal knowledge base",
-        parameters: z.object({
-          query: z.string(),
-        }),
-        execute: async ({ query }: { query: string }) => {
-          const persistentMemories =
-            await this.memory.persistent.findRelevantDocuments(query, {
-              similarityThreshold: 70,
-            });
-          return `# LONG_TERM_MEMORY: ${JSON.stringify(persistentMemories)}`;
-        },
-      },
-    ];
+    this.cache = new RedisCache(redisConfig);
+    this.scheduler = new TaskScheduler(this, this.cache);
   }
 
-  composeContext(state: State) {
-    const { userRequest, results } = state;
-    const { role, language, guidelines } = orchestratorContext.behavior;
-    const { important, warnings } = guidelines;
-
-    const context = `
-      # ROLE: ${role}
-      # LANGUAGE: ${language}
-      # IMPORTANT: ${important.join("\n")}
-      # USER_REQUEST: ${userRequest}
-      # ACTIONS_AVAILABLES: ${injectActions(this.tools)} (NEVER REPEAT ACTIONS)
-      # CURRENT_RESULTS: ${results}
-    `.trim();
-
-    return context;
+  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(
-    prompt: string,
-    results: string
-  ): Promise<{
-    actions: {
+  async process(state: State): Promise<{
+    shouldContinue: boolean;
+    actions: Array<{
       name: string;
-      type: string;
-      parameters: {
+      parameters: Array<{
         name: string;
         value: any;
-      }[];
-    }[];
-    answer: string;
-  }> {
-    const state = this.composeContext({
-      userRequest: prompt,
-      results: results,
-    });
-    try {
-      console.log("\n🎭 Orchestrator processing");
-      console.log("Prompt:", prompt);
-
-      const response = await generateObject({
-        model: this.model,
-        schema: z.object({
-          actions: z.array(
-            z.object({
-              name: z.string(),
-              type: z.enum(["on-chain", "off-chain", "question", "analysis"]),
-              parameters: z.array(
-                z.object({
-                  name: z.string(),
-                  value: z.any(),
-                })
-              ),
-            })
-          ),
-          answer: z.string(),
-        }),
-        prompt: prompt,
-        system: state,
-        temperature: 0,
-      });
-
-      const validatedResponse = {
-        ...response.object,
-        actions: response.object.actions.map((action) => ({
-          ...action,
-          parameters: Array.isArray(action.parameters)
-            ? action.parameters.map((param) => ({
-                name: param.name,
-                value: param.value ?? null,
-              }))
-            : Object.entries(action.parameters || {}).map(([name, value]) => ({
-                name,
-                value: value ?? null,
-              })),
-        })),
+      }>;
+      scheduler?: {
+        isScheduled: boolean;
+        scheduledAtInC?: string;
+        interval?: string;
+        reason?: string;
       };
-
-      console.log("\n✅ Orchestration completed");
-      console.log("─".repeat(50));
+    }>;
+    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(
-        "Actions determined:",
-        validatedResponse.actions.map((a) => {
-          return `${a.name} (${a.type})`;
-        })
+        "📊 Previous actions:",
+        state.previousActions
+          .map((a) => (typeof a === "string" ? a : a.name))
+          .join(", ")
       );
-      if (validatedResponse.answer) {
-        console.log("Response:", validatedResponse.answer);
+    }
+
+    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
       }
+    }
 
-      return validatedResponse;
-    } catch (error: any) {
-      console.error("\n❌ Orchestrator error:", error.message);
-      if (error?.value) {
-        console.log("Partial response:", JSON.stringify(error.value, null, 2));
-        return { ...error.value };
+    // 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,
+        });
       }
-      throw error;
     }
+
+    // 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

@@ -0,0 +1,14 @@
+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>;
+}