@ai.ntellect/core 0.4.0 → 0.5.0

package/llm/interpreter/context.ts

@@ -11,18 +11,9 @@ export type Character = {
   }[];
 };
 
-export const generalInterpreterCharacter: Character = {
-  role: "You are the general assistant. Your role is to provide a clear and factual analysis of the results.",
-  language: "user_request",
-  guidelines: {
-    important: [],
-    warnings: [],
-  },
-};
-
 export const securityInterpreterCharacter: Character = {
   role: "You are the security expert. Your role is to provide a clear and factual analysis of the security of the token/coin.",
-  language: "user_request",
+  language: "same_as_request",
   guidelines: {
     important: [
       "Start with a clear security analysis of the token/coin.",
@@ -52,7 +43,8 @@ export const securityInterpreterCharacter: Character = {
   
       ### Bad:
       Speak about the bad points of the security check. If there is no bad point, say "No bad point found"
-  
+   
+      TRANSLATE ALL THE TEXT TO LANGUAGE OF THE USER REQUEST
       STOP AFTER SECURITY CHECK SECTION WITHOUT ANY CONCLUDING STATEMENT OR DISCLAIMER OR ADDITIONAL COMMENTS
       --------------------------------
       `,
@@ -62,7 +54,7 @@ export const securityInterpreterCharacter: Character = {
 
 export const marketInterpreterCharacter: Character = {
   role: "You are the market expert. Your role is to provide a clear and factual analysis of the market sentiment of the token/coin.",
-  language: "user_request",
+  language: "same_as_request",
   guidelines: {
     important: [
       "Start with a clear market sentiment (Market sentiment: Bullish/Bearish/Neutral 📈📉📊) without any additional comments before.",
@@ -93,6 +85,7 @@ export const marketInterpreterCharacter: Character = {
     ### Technical analysis (No sub-sections):
     Speak about key price levels, trading volume, technical indicators, market activity..etc
 
+    TRANSLATE ALL THE TEXT TO LANGUAGE OF THE USER REQUEST
     STOP AFTER TECHNICAL ANALYSIS SECTION WITHOUT ANY CONCLUDING STATEMENT OR DISCLAIMER OR ADDITIONAL COMMENTS
     --------------------------------
     `,

package/llm/interpreter/index.ts

@@ -1,8 +1,9 @@
 import { LanguageModel, streamText, StreamTextResult } from "ai";
 import { z } from "zod";
-import { Behavior, State } from "../../types";
+import { Behavior, MyContext, SharedState } from "../../types";
 import { generateObject } from "../../utils/generate-object";
 import { LLMHeaderBuilder } from "../../utils/header-builder";
+import { State } from "../orchestrator/types";
 
 const interpreterSchema = z.object({
   requestLanguage: z
@@ -46,8 +47,7 @@ export class Interpreter {
     this.character = character;
   }
 
-  private buildContext(state: State) {
-    const { userRequest, results } = state;
+  private buildContext() {
     const { role, language, guidelines } = this.character;
     const { important, warnings, steps } = guidelines;
 
@@ -68,14 +68,11 @@ export class Interpreter {
     if (warnings.length > 0) {
       context.addHeader("NEVER", warnings);
     }
-
-    context.addHeader("CURRENT_RESULTS", results);
     return context;
   }
 
   async process(
-    prompt: string,
-    state: State,
+    state: SharedState<MyContext>,
     onFinish?: (event: any) => void
   ): Promise<
     | {
@@ -88,17 +85,24 @@ export class Interpreter {
     | StreamTextResult<Record<string, any>>
   > {
     try {
-      console.log("\n🎨 Starting interpretation process");
-      console.log("Prompt:", prompt);
-      console.log("Results to interpret:", JSON.stringify(state, null, 2));
-
-      const context = this.buildContext(state);
-      console.log("Context:", context.toString());
+      console.log("\n🎨 Start ing interpretation process");
+
+      const context = this.buildContext();
+      let prompt = LLMHeaderBuilder.create();
+      if (state.messages) {
+        prompt.addHeader(
+          "REQUEST",
+          state.messages[state.messages.length - 2].content.toString()
+        );
+      }
+      if (state.context.results) {
+        prompt.addHeader("RESULTS", JSON.stringify(state.context.results));
+      }
       const result = await generateObject<InterpretationResult>({
         model: this.model,
-        prompt,
+        prompt: prompt.toString(),
         system: context.toString(),
-        temperature: 1.3,
+        temperature: 0.5,
         schema: interpreterSchema,
       });
 
@@ -118,7 +122,7 @@ export class Interpreter {
     console.log("\n🎨 Starting streaming interpretation");
     console.log("Prompt:", prompt);
 
-    const context = this.buildContext(state);
+    const context = this.buildContext();
 
     const result = await streamText({
       model: this.model,

package/llm/memory-manager/context.ts

@@ -1,15 +1,13 @@
 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",
+  role: "You are the memory curator. Your role is to extract relevant memories from interactions.",
+  language: "same_as_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",
+      "Generate query for requested data as the user could ask for it later (Eg: 'What is the price of Bitcoin today?')s",
+      "Short-term memories need to be necessary 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: [

package/llm/memory-manager/index.ts

@@ -2,10 +2,9 @@ import { LanguageModelV1 } from "ai";
 import { z } from "zod";
 import { CacheMemory } from "../../memory/cache";
 import { PersistentMemory } from "../../memory/persistent";
-import { MemoryScope } from "../../types";
+import { MyContext, SharedState } 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 {
@@ -27,7 +26,7 @@ interface MemoryResponse {
 }
 export class MemoryManager {
   private readonly model: LanguageModelV1;
-  private readonly memory?: {
+  public readonly memory?: {
     cache?: CacheMemory;
     persistent?: PersistentMemory;
   };
@@ -43,19 +42,39 @@ export class MemoryManager {
     this.memory = config.memory;
   }
 
-  buildContext(state: State) {
+  buildContext() {
     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));
+      .addHeader("WARNINGS", memoryManagerInstructions.guidelines.warnings);
     return context.toString();
   }
 
-  async process(state: State, result: string) {
-    const context = this.buildContext(state);
+  async process(
+    state: SharedState<MyContext>,
+    callbacks?: {
+      onMemoriesGenerated?: (event: any) => void;
+    }
+  ) {
+    const context = this.buildContext();
+    let prompt = LLMHeaderBuilder.create();
+    if (state.messages) {
+      prompt.addHeader(
+        "REQUEST",
+        state.messages[state.messages.length - 2].content.toString()
+      );
+    }
+    if (state.messages && state.messages.length > 0) {
+      prompt.addHeader("RECENT_MESSAGES", JSON.stringify(state.messages));
+    }
+
+    if (state.context.actions) {
+      prompt.addHeader(
+        "PREVIOUS_ACTIONS",
+        JSON.stringify(state.context.actions)
+      );
+    }
 
     const memories = await generateObject<MemoryResponse>({
       model: this.model,
@@ -79,85 +98,18 @@ export class MemoryManager {
           })
         ),
       }),
-      prompt: state.currentContext,
       system: context.toString(),
       temperature: 1,
+      prompt: prompt.toString(),
     });
 
-    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;
-          }
+    if (callbacks?.onMemoriesGenerated)
+      callbacks.onMemoriesGenerated(memories.object);
 
-          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);
-        }),
-    ]);
+    return memories.object;
   }
 }

package/llm/orchestrator/context.ts

@@ -1,16 +1,13 @@
 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",
+  role: "Your role is to evaluate the current state and determine next actions.",
+  language: "same_as_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",
+      "If no actions are needed, just answer",
+      "If required, you can schedule actions in cron expression to be executed later",
+      "If required, you choose one interpreter to interpret the results when you have a complete picture of the goal",
     ],
     warnings: [
       "Never use a tool if it's not related to the user request",

package/llm/orchestrator/index.ts

@@ -1,30 +1,17 @@
-import { LanguageModelV1 } from "ai";
+import { generateObject, 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 { ActionSchema, MemoryScope, MyContext, SharedState } from "../../types";
 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 {
+export class Orchestrator {
   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;
@@ -34,23 +21,18 @@ export class AgentRuntime {
     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> {
+  private async buildContext(state: SharedState<MyContext>): Promise<string> {
     console.log("🧠 Building context with RAG and CAG...");
     const context = LLMHeaderBuilder.create();
 
@@ -65,18 +47,10 @@ export class AgentRuntime {
     // 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) {
+    if (this.memory?.cache && state.messages) {
       const cacheMemories = await this.memory.cache.findSimilarActions(
-        state.currentContext,
+        state.messages[state.messages.length - 1].content.toString(),
         {
           similarityThreshold: 80,
           maxResults: 3,
@@ -90,10 +64,10 @@ export class AgentRuntime {
     }
 
     // Get relevant knowledge (RAG)
-    if (this.memory?.persistent) {
+    if (this.memory?.persistent && state.messages) {
       const persistentMemory =
         await this.memory.persistent.findRelevantDocuments(
-          state.currentContext,
+          state.messages[state.messages.length - 1].content.toString(),
           {
             similarityThreshold: 80,
           }
@@ -109,15 +83,25 @@ export class AgentRuntime {
 
     // Add available interpreters
     context.addHeader(
-      "AVAILABLE_INTERPRETERS",
+      "INTERPRETERS (choose one)",
       JSON.stringify(this.interpreters.map((i) => i.name))
+        .replace("[", "")
+        .replace("]", "")
     );
-    console.log("Context built with memories", context.toString());
     return context.toString();
   }
 
-  async process(state: State): Promise<{
-    shouldContinue: boolean;
+  async process(
+    state: SharedState<MyContext>,
+    callbacks?: {
+      onStart?: () => void;
+      onFinish?: (event: any) => void;
+    }
+  ): Promise<{
+    processing: {
+      stop: boolean;
+      stopReason?: string;
+    };
     actions: Array<{
       name: string;
       parameters: Array<{
@@ -126,37 +110,40 @@ export class AgentRuntime {
       }>;
       scheduler?: {
         isScheduled: boolean;
-        scheduledAtInC?: string;
-        interval?: string;
+        cronExpression?: string;
         reason?: string;
       };
     }>;
-    socialResponse?: {
-      shouldRespond: boolean;
-      response?: string;
-      isPartialResponse?: boolean;
-    };
-    interpreter?: string;
+    response: string;
+    interpreter?: string | null;
     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(", ")
-      );
-    }
+    if (callbacks?.onStart) callbacks.onStart();
 
     const context = await this.buildContext(state);
+    let prompt = LLMHeaderBuilder.create();
+    if (state.messages) {
+      prompt.addHeader(
+        "REQUEST",
+        state.messages[state.messages.length - 1].content.toString()
+      );
+
+      if (state.messages.length > 1) {
+        prompt.addHeader("RECENT_MESSAGES", JSON.stringify(state.messages));
+      }
+    }
+    if (state.context.results) {
+      prompt.addHeader("ACTIONS_DONE", JSON.stringify(state.context.results));
+    }
 
-    console.log("\n🧠 Generating response from LLM...");
-    const response = await generateObject<GenerateObjectResponse>({
+    console.log("\n🧠 Generating response from Orchestrator...");
+    const response = await generateObject({
       model: this.model,
       schema: z.object({
-        shouldContinue: z.boolean(),
+        processing: z.object({
+          stop: z.boolean(),
+          reason: z.string(),
+        }),
         actions: z.array(
           z.object({
             name: z.string(),
@@ -166,67 +153,40 @@ export class AgentRuntime {
                 value: z.any(),
               })
             ),
-            scheduler: z
-              .object({
-                isScheduled: z.boolean(),
-                cronExpression: z.string().optional(),
-                reason: z.string().optional(),
-              })
-              .optional(),
+            scheduler: z.object({
+              isScheduled: z.boolean(),
+              cronExpression: z.string(),
+              reason: z.string(),
+            }),
           })
         ),
-        socialResponse: z
-          .object({
-            shouldRespond: z.boolean(),
-            response: z.string().optional(),
-            isPartialResponse: z.boolean().optional(),
-          })
-          .optional(),
-        interpreter: z.string().optional(),
+        response: z.string(),
+        interpreter: z.string().or(z.null()),
       }),
-      prompt: state.currentContext,
       system: context.toString(),
       temperature: 0,
+      prompt: prompt.toString(),
     });
     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");
+      response.object.processing.stop = true;
+      console.log("⚠️ No actions planned, forcing isProcessing to false");
     }
 
     // Handle social interactions and actions in a single block
-    if (response.object.socialResponse?.shouldRespond) {
+    if (response.object.response) {
       console.log("\n💬 Processing social response");
-      if (response.object.socialResponse.response) {
-        console.log("📢 Response:", response.object.socialResponse.response);
+      if (response.object.response) {
+        console.log("📢 Response:", response.object.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,
-    });
+    if (callbacks?.onFinish) callbacks.onFinish(response.object);
 
-    return response.object;
+    return response.object as any;
   }
 }

package/llm/orchestrator/types.ts

@@ -1,11 +1,11 @@
+import { CoreMessage } from "ai";
 import { QueueResult } from "../../types";
 
 export interface State {
   currentContext: string;
   previousActions: (string | QueueResult)[];
-  reward?: number;
-  userRequest?: string;
   results?: string;
+  recentMessages: CoreMessage[];
 }
 
 export interface Action {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai.ntellect/core",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "",
   "main": "dist/index.js",
   "scripts": {
@@ -16,7 +16,9 @@
     "@ai-sdk/openai": "1.0.6",
     "@types/node-cron": "^3.0.11",
     "ai": "^3.0.0",
+    "chalk": "^5.4.1",
     "ethers": "^6.13.5",
+    "ioredis": "^5.4.2",
     "langchain": "^0.3.11",
     "node-cron": "^3.0.3",
     "readline": "^1.3.0",