@ai.ntellect/core 0.3.3 → 0.4.0

package/dist/llm/interpreter/index.js

@@ -1,69 +1,75 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Interpreter = void 0;
-const openai_1 = require("@ai-sdk/openai");
 const ai_1 = require("ai");
 const zod_1 = require("zod");
+const generate_object_1 = require("../../utils/generate-object");
+const header_builder_1 = require("../../utils/header-builder");
+const interpreterSchema = zod_1.z.object({
+    requestLanguage: zod_1.z
+        .string()
+        .describe("The language of the user's request (fr, en, es, etc.)"),
+    actionsCompleted: zod_1.z
+        .array(zod_1.z.object({
+        name: zod_1.z.string(),
+        reasoning: zod_1.z.string(),
+    }))
+        .describe("The actions done and why."),
+    response: zod_1.z.string().describe("The response to the user's request."),
+});
 class Interpreter {
-    constructor(name, behavior) {
-        this.behavior = behavior;
-        this.model = (0, openai_1.openai)("gpt-4o");
+    constructor({ name, model, character, }) {
         this.name = name;
-        this.behavior = behavior;
+        this.model = model;
+        this.character = character;
     }
-    composeContext(state) {
+    buildContext(state) {
         const { userRequest, results } = state;
-        const { role, language, guidelines, examplesMessages } = this.behavior;
+        const { role, language, guidelines } = this.character;
         const { important, warnings, steps } = guidelines;
-        const context = `
-      # ROLE: ${role}
-      # LANGUAGE: ${language}
-      # IMPORTANT: ${important.join("\n")}
-      # NEVER: ${warnings.join("\n")}
-      # USER_REQUEST: ${userRequest}
-      # CURRENT_RESULTS: ${results}
-      # STEPS: ${steps?.join("\n") || ""}
-      # MESSAGES EXAMPLES: ${JSON.stringify(examplesMessages, null, 2)}
-    `;
+        const context = header_builder_1.LLMHeaderBuilder.create();
+        if (role) {
+            context.addHeader("ROLE", role);
+        }
+        if (language) {
+            context.addHeader("LANGUAGE", language);
+        }
+        if (important.length > 0) {
+            context.addHeader("IMPORTANT", important);
+        }
+        if (warnings.length > 0) {
+            context.addHeader("NEVER", warnings);
+        }
+        context.addHeader("CURRENT_RESULTS", results);
         return context;
     }
     async process(prompt, state, onFinish) {
-        console.log("\n🎨 Starting interpretation process");
-        console.log("Prompt:", prompt);
-        console.log("Results to interpret:", JSON.stringify(state, null, 2));
-        const context = this.composeContext(state);
-        const result = await (0, ai_1.generateObject)({
-            model: this.model,
-            schema: zod_1.z.object({
-                requestLanguage: zod_1.z.string(),
-                actionsCompleted: zod_1.z.array(zod_1.z.object({
-                    name: zod_1.z.string(),
-                    reasoning: zod_1.z.string(),
-                })),
-                response: zod_1.z.string(),
-            }),
-            prompt,
-            system: context,
-        });
-        console.log("\n✅ Interpretation completed");
-        console.log("─".repeat(50));
-        console.log("Generated response:", result.object);
-        if (result.object.actionsCompleted.length > 0) {
-            console.log("\n📋 Suggested actions:");
-            result.object.actionsCompleted.forEach((action, index) => {
-                console.log(`\n${index + 1}. Action Details:`);
-                console.log(`   Name: ${action.name}`);
-                console.log(`   Reasoning: ${action.reasoning}`);
+        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());
+            const result = await (0, generate_object_1.generateObject)({
+                model: this.model,
+                prompt,
+                system: context.toString(),
+                temperature: 1.3,
+                schema: interpreterSchema,
             });
+            if (onFinish)
+                onFinish(result.object);
+            return result.object;
+        }
+        catch (error) {
+            console.error("Error parsing schema:", error);
+            throw error;
         }
-        if (onFinish)
-            onFinish(result.object);
-        return result.object;
     }
     async streamProcess(prompt, state, onFinish) {
         console.log("\n🎨 Starting streaming interpretation");
         console.log("Prompt:", prompt);
-        const context = this.composeContext(state);
+        const context = this.buildContext(state);
         const result = await (0, ai_1.streamText)({
             model: this.model,
             onFinish: (event) => {
@@ -72,7 +78,8 @@ class Interpreter {
                     onFinish(event);
             },
             prompt,
-            system: context,
+            system: context.toString(),
+            temperature: 1.3,
         });
         return result;
     }

package/dist/llm/memory-manager/context.d.ts

@@ -0,0 +1,2 @@
+import { Character } from "../interpreter/context";
+export declare const memoryManagerInstructions: Character;

package/dist/llm/memory-manager/context.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.memoryManagerInstructions = void 0;
+exports.memoryManagerInstructions = {
+    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/dist/llm/memory-manager/index.d.ts

@@ -0,0 +1,17 @@
+import { LanguageModelV1 } from "ai";
+import { CacheMemory } from "../../memory/cache";
+import { PersistentMemory } from "../../memory/persistent";
+import { State } from "../orchestrator/types";
+export declare class MemoryManager {
+    private readonly model;
+    private readonly memory?;
+    constructor(config: {
+        model: LanguageModelV1;
+        memory?: {
+            cache?: CacheMemory;
+            persistent?: PersistentMemory;
+        };
+    });
+    buildContext(state: State): string;
+    process(state: State, result: string): Promise<void>;
+}

package/dist/llm/memory-manager/index.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryManager = void 0;
+const zod_1 = require("zod");
+const types_1 = require("../../types");
+const generate_object_1 = require("../../utils/generate-object");
+const header_builder_1 = require("../../utils/header-builder");
+const context_1 = require("./context");
+class MemoryManager {
+    constructor(config) {
+        this.model = config.model;
+        this.memory = config.memory;
+    }
+    buildContext(state) {
+        const context = header_builder_1.LLMHeaderBuilder.create()
+            .addHeader("ROLE", context_1.memoryManagerInstructions.role)
+            .addHeader("LANGUAGE", context_1.memoryManagerInstructions.language)
+            .addHeader("IMPORTANT", context_1.memoryManagerInstructions.guidelines.important)
+            .addHeader("WARNINGS", context_1.memoryManagerInstructions.guidelines.warnings)
+            .addHeader("CURRENT_CONTEXT", state.currentContext)
+            .addHeader("RESULTS", JSON.stringify(state.results));
+        return context.toString();
+    }
+    async process(state, result) {
+        const context = this.buildContext(state);
+        const memories = await (0, generate_object_1.generateObject)({
+            model: this.model,
+            schema: zod_1.z.object({
+                memories: zod_1.z.array(zod_1.z.object({
+                    data: zod_1.z.string(),
+                    type: zod_1.z.enum(["short-term", "long-term"]),
+                    category: zod_1.z.enum([
+                        "user_information",
+                        "user_preference",
+                        "task",
+                        "current_goal",
+                        "news",
+                        "fact",
+                        "other",
+                    ]),
+                    queryForData: zod_1.z.string(),
+                    tags: zod_1.z.array(zod_1.z.string()),
+                    ttl: zod_1.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) => m.type === "short-term")
+                .map(async (memoryItem) => {
+                if (!this.memory?.cache) {
+                    return;
+                }
+                const existingCacheMemories = await this.memory.cache.findSimilarActions(memoryItem.data, {
+                    similarityThreshold: 85,
+                    maxResults: 3,
+                    scope: types_1.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);
+            }),
+        ]);
+    }
+}
+exports.MemoryManager = MemoryManager;

package/dist/llm/orchestrator/context.d.ts

@@ -1,10 +1,2 @@
-export declare const orchestratorContext: {
-    behavior: {
-        language: string;
-        role: string;
-        guidelines: {
-            important: string[];
-            warnings: string[];
-        };
-    };
-};
+import { Character } from "../interpreter/context";
+export declare const orchestratorInstructions: Character;

package/dist/llm/orchestrator/context.js

@@ -1,18 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.orchestratorContext = void 0;
-exports.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."],
-        },
+exports.orchestratorInstructions = void 0;
+exports.orchestratorInstructions = {
+    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/dist/llm/orchestrator/index.d.ts

@@ -1,29 +1,44 @@
+import { LanguageModelV1 } from "ai";
 import { CacheMemory } from "../../memory/cache";
 import { PersistentMemory } from "../../memory/persistent";
-import { ActionSchema, State } from "../../types";
-export declare class Orchestrator {
+import { CacheConfig } from "../../services/redis-cache";
+import { ActionSchema, QueueCallbacks } from "../../types";
+import { Interpreter } from "../interpreter";
+import { State } from "./types";
+export declare class AgentRuntime {
     private readonly model;
-    tools: ActionSchema[];
-    private memory;
-    private id;
-    constructor({ id, tools, memory, }: {
-        id: string;
-        tools: ActionSchema[];
-        memory: {
-            persistent: PersistentMemory;
-            cache: CacheMemory;
-        };
-    });
-    composeContext(state: State): string;
-    process(prompt: string, results: string): Promise<{
-        actions: {
+    private readonly tools;
+    private readonly interpreters;
+    private readonly queueManager;
+    private readonly scheduler;
+    private readonly cache;
+    private memory?;
+    constructor(model: LanguageModelV1, tools: ActionSchema[], interpreters: Interpreter[], redisConfig: CacheConfig, memory?: {
+        persistent?: PersistentMemory;
+        cache?: CacheMemory;
+    }, callbacks?: QueueCallbacks);
+    private buildContext;
+    process(state: State): Promise<{
+        shouldContinue: boolean;
+        actions: Array<{
             name: string;
-            type: string;
-            parameters: {
+            parameters: Array<{
                 name: string;
                 value: any;
-            }[];
-        }[];
-        answer: string;
+            }>;
+            scheduler?: {
+                isScheduled: boolean;
+                scheduledAtInC?: string;
+                interval?: string;
+                reason?: string;
+            };
+        }>;
+        socialResponse?: {
+            shouldRespond: boolean;
+            response?: string;
+            isPartialResponse?: boolean;
+        };
+        interpreter?: string;
+        results?: string;
     }>;
 }

package/dist/llm/orchestrator/index.js

@@ -1,105 +1,139 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Orchestrator = void 0;
-const openai_1 = require("@ai-sdk/openai");
-const ai_1 = require("ai");
+exports.AgentRuntime = void 0;
 const zod_1 = require("zod");
+const queue_1 = require("../../services/queue");
+const redis_cache_1 = require("../../services/redis-cache");
+const scheduler_1 = require("../../services/scheduler");
+const types_1 = require("../../types");
+const generate_object_1 = require("../../utils/generate-object");
+const header_builder_1 = require("../../utils/header-builder");
 const inject_actions_1 = require("../../utils/inject-actions");
 const context_1 = require("./context");
-class Orchestrator {
-    constructor({ id, tools, memory, }) {
-        this.model = (0, openai_1.openai)("gpt-4o");
-        this.id = id;
+class AgentRuntime {
+    constructor(model, tools, interpreters, redisConfig, memory, callbacks) {
+        this.model = model;
+        this.tools = tools;
+        this.interpreters = interpreters;
+        this.queueManager = new queue_1.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: zod_1.z.object({
-                    query: zod_1.z.string(),
-                }),
-                execute: async ({ query }) => {
-                    const persistentMemories = await this.memory.persistent.findRelevantDocuments(query, {
-                        similarityThreshold: 70,
-                    });
-                    return `# LONG_TERM_MEMORY: ${JSON.stringify(persistentMemories)}`;
-                },
-            },
-        ];
+        this.cache = new redis_cache_1.RedisCache(redisConfig);
+        this.scheduler = new scheduler_1.TaskScheduler(this, this.cache);
     }
-    composeContext(state) {
-        const { userRequest, results } = state;
-        const { role, language, guidelines } = context_1.orchestratorContext.behavior;
-        const { important, warnings } = guidelines;
-        const context = `
-      # ROLE: ${role}
-      # LANGUAGE: ${language}
-      # IMPORTANT: ${important.join("\n")}
-      # USER_REQUEST: ${userRequest}
-      # ACTIONS_AVAILABLES: ${(0, inject_actions_1.injectActions)(this.tools)} (NEVER REPEAT ACTIONS)
-      # CURRENT_RESULTS: ${results}
-    `.trim();
-        return context;
+    async buildContext(state) {
+        console.log("🧠 Building context with RAG and CAG...");
+        const context = header_builder_1.LLMHeaderBuilder.create();
+        // Add orchestrator instructions
+        context.addHeader("ROLE", context_1.orchestratorInstructions.role);
+        context.addHeader("LANGUAGE", context_1.orchestratorInstructions.language);
+        context.addHeader("IMPORTANT", context_1.orchestratorInstructions.guidelines.important);
+        context.addHeader("WARNINGS", context_1.orchestratorInstructions.guidelines.warnings);
+        // Add tools to context
+        context.addHeader("TOOLS", (0, inject_actions_1.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: types_1.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, results) {
-        const state = this.composeContext({
-            userRequest: prompt,
-            results: results,
-        });
-        try {
-            console.log("\n🎭 Orchestrator processing");
-            console.log("Prompt:", prompt);
-            const response = await (0, ai_1.generateObject)({
-                model: this.model,
-                schema: zod_1.z.object({
-                    actions: zod_1.z.array(zod_1.z.object({
+    async process(state) {
+        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 (0, generate_object_1.generateObject)({
+            model: this.model,
+            schema: zod_1.z.object({
+                shouldContinue: zod_1.z.boolean(),
+                actions: 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(),
-                        type: zod_1.z.enum(["on-chain", "off-chain", "question", "analysis"]),
-                        parameters: zod_1.z.array(zod_1.z.object({
-                            name: zod_1.z.string(),
-                            value: zod_1.z.any(),
-                        })),
+                        value: zod_1.z.any(),
                     })),
-                    answer: zod_1.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: zod_1.z
+                        .object({
+                        isScheduled: zod_1.z.boolean(),
+                        cronExpression: zod_1.z.string().optional(),
+                        reason: zod_1.z.string().optional(),
+                    })
+                        .optional(),
                 })),
-            };
-            console.log("\n✅ Orchestration completed");
-            console.log("─".repeat(50));
-            console.log("Actions determined:", validatedResponse.actions.map((a) => {
-                return `${a.name} (${a.type})`;
-            }));
-            if (validatedResponse.answer) {
-                console.log("Response:", validatedResponse.answer);
+                socialResponse: zod_1.z
+                    .object({
+                    shouldRespond: zod_1.z.boolean(),
+                    response: zod_1.z.string().optional(),
+                    isPartialResponse: zod_1.z.boolean().optional(),
+                })
+                    .optional(),
+                interpreter: zod_1.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) {
-            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;
     }
 }
-exports.Orchestrator = Orchestrator;
+exports.AgentRuntime = AgentRuntime;

package/dist/llm/orchestrator/types.d.ts

@@ -0,0 +1,12 @@
+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/dist/llm/orchestrator/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });