@ai.ntellect/core 0.3.3 → 0.4.0

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>;
+}

package/memory/cache.ts

@@ -1,5 +1,5 @@
 import { openai } from "@ai-sdk/openai";
-import { cosineSimilarity, embed } from "ai";
+import { cosineSimilarity, embed, EmbeddingModel } from "ai";
 import { createClient } from "redis";
 import {
   CacheMemoryOptions,
@@ -7,16 +7,16 @@ import {
   CreateMemoryInput,
   MatchOptions,
   MemoryScope,
-  MemoryType,
-  QueueResult,
 } 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 = {}) {
+  constructor(options: CacheMemoryOptions) {
+    this.embeddingModel = options.embeddingModel;
     const ttlInHours = options.cacheTTL ?? 1;
     this.CACHE_TTL = ttlInHours * 60 * 60;
     this.CACHE_PREFIX = options.cachePrefix ?? "memory:";
@@ -44,11 +44,11 @@ export class CacheMemory {
     }
   }
 
-  private async storeMemory(memory: CacheMemoryType) {
+  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: this.CACHE_TTL,
+      EX: ttl || this.CACHE_TTL,
     });
     console.log("💾 Cache memory created:", result);
   }
@@ -58,9 +58,9 @@ export class CacheMemory {
     options: MatchOptions & { userId?: string; scope?: MemoryScope } = {}
   ): Promise<
     {
-      actions: QueueResult[];
-      similarityPercentage: number;
+      data: any;
       query: string;
+      createdAt: Date;
     }[]
   > {
     console.log("\n🔍 Searching in cache");
@@ -72,7 +72,7 @@ export class CacheMemory {
       value: query,
     });
 
-    const memories = await this.getAllMemories(options.scope, options.userId);
+    const memories = await this.getAllMemories();
     console.log(`\n📚 Found ${memories.length} cached queries to compare`);
 
     const matches = memories
@@ -80,7 +80,7 @@ export class CacheMemory {
         const similarity = cosineSimilarity(embedding, memory.embedding);
         const similarityPercentage = (similarity + 1) * 50;
         return {
-          actions: memory.data,
+          data: memory.data,
           query: memory.query,
           similarityPercentage,
           createdAt: memory.createdAt,
@@ -103,6 +103,7 @@ export class CacheMemory {
       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));
       });
@@ -110,13 +111,16 @@ export class CacheMemory {
       console.log("\n❌ No similar queries found in cache");
     }
 
-    return results;
+    return results.map((match) => {
+      return {
+        data: match.data,
+        query: match.query,
+        createdAt: match.createdAt,
+      };
+    });
   }
 
-  async getAllMemories(
-    scope?: MemoryScope,
-    userId?: string
-  ): Promise<CacheMemoryType[]> {
+  async getAllMemories(): Promise<CacheMemoryType[]> {
     const keys = await this.redis.keys(`${this.CACHE_PREFIX}*`);
     const memories = await this.getMemoriesFromKeys(keys);
 
@@ -140,11 +144,10 @@ export class CacheMemory {
     input: CreateMemoryInput
   ): Promise<CacheMemoryType | undefined> {
     console.log("\n📝 Processing new memory creation");
-    console.log("Content:", input.content);
-    console.log("Type:", input.type);
-    console.log("Scope:", input.scope);
+    console.log("Content:", input.query);
+    console.log("TTL:", input.ttl ? `${input.ttl} seconds` : "default");
 
-    const existingPattern = await this.findSimilarActions(input.content, {
+    const existingPattern = await this.findSimilarActions(input.query, {
       similarityThreshold: 95,
       userId: input.userId,
       scope: input.scope,
@@ -156,7 +159,8 @@ export class CacheMemory {
       existingPattern.forEach((match, index) => {
         console.log(`\n${index + 1}. Existing Match:`);
         console.log(`   Query: ${match.query}`);
-        console.log(`   Similarity: ${match.similarityPercentage.toFixed(2)}%`);
+        console.log(`   Data: ${JSON.stringify(match.data)}`);
+        console.log(`   Created At: ${match.createdAt}`);
       });
       console.log("\n⏭️  Skipping creation of new memory");
       return;
@@ -166,11 +170,11 @@ export class CacheMemory {
 
     const memory = await this.createSingleMemory({
       id: crypto.randomUUID(),
-      content: input.content,
-      type: input.type,
+      query: input.query,
       data: input.data,
       userId: input.userId,
       scope: input.scope,
+      ttl: input.ttl,
     });
 
     return memory;
@@ -178,28 +182,27 @@ export class CacheMemory {
 
   private async createSingleMemory(params: {
     id: string;
-    content: string;
-    type: MemoryType;
+    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.content);
+    console.log("Content:", params.query);
 
     console.log("\n🧮 Generating embedding...");
     const { embedding } = await embed({
-      model: openai.embedding("text-embedding-3-small"),
-      value: params.content,
+      model: this.embeddingModel,
+      value: params.query,
     });
     console.log("✅ Embedding generated successfully");
 
     const memory: CacheMemoryType = {
       id: params.id,
-      type: params.type,
       data: params.data,
-      query: params.content,
+      query: params.query,
       embedding,
       userId: params.userId,
       scope:
@@ -207,8 +210,11 @@ export class CacheMemory {
       createdAt: new Date(),
     };
 
-    await this.storeMemory(memory);
-    console.log("✅ Memory created and stored successfully");
+    await this.storeMemory(memory, params.ttl);
+    console.log("✅ Short-term memory created and stored successfully", {
+      ...memory,
+      ttl: params.ttl || this.CACHE_TTL,
+    });
 
     return memory;
   }