@ai.ntellect/core 0.4.1 → 0.6.0

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

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

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

@@ -1,107 +0,0 @@
-"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,2 +0,0 @@
-import { Character } from "../interpreter/context";
-export declare const orchestratorInstructions: Character;

package/dist/llm/orchestrator/context.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-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,44 +0,0 @@
-import { LanguageModelV1 } from "ai";
-import { CacheMemory } from "../../memory/cache";
-import { PersistentMemory } from "../../memory/persistent";
-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;
-    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;
-            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;
-    }>;
-}

package/dist/llm/orchestrator/index.js

@@ -1,139 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-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 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.cache = new redis_cache_1.RedisCache(redisConfig);
-        this.scheduler = new scheduler_1.TaskScheduler(this, this.cache);
-    }
-    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(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(),
-                        value: zod_1.z.any(),
-                    })),
-                    scheduler: zod_1.z
-                        .object({
-                        isScheduled: zod_1.z.boolean(),
-                        cronExpression: zod_1.z.string().optional(),
-                        reason: zod_1.z.string().optional(),
-                    })
-                        .optional(),
-                })),
-                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
-            }
-        }
-        // 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;
-    }
-}
-exports.AgentRuntime = AgentRuntime;

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

@@ -1,12 +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/dist/memory/cache.d.ts

@@ -1,22 +0,0 @@
-import { CacheMemoryOptions, CacheMemoryType, CreateMemoryInput, MatchOptions, MemoryScope } from "../types";
-export declare class CacheMemory {
-    private redis;
-    private readonly CACHE_PREFIX;
-    private readonly CACHE_TTL;
-    private readonly embeddingModel;
-    constructor(options: CacheMemoryOptions);
-    private initRedis;
-    private storeMemory;
-    findSimilarActions(query: string, options?: MatchOptions & {
-        userId?: string;
-        scope?: MemoryScope;
-    }): Promise<{
-        data: any;
-        query: string;
-        createdAt: Date;
-    }[]>;
-    getAllMemories(): Promise<CacheMemoryType[]>;
-    private getMemoriesFromKeys;
-    createMemory(input: CreateMemoryInput): Promise<CacheMemoryType | undefined>;
-    private createSingleMemory;
-}

package/dist/memory/cache.js

@@ -1,165 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CacheMemory = void 0;
-const openai_1 = require("@ai-sdk/openai");
-const ai_1 = require("ai");
-const redis_1 = require("redis");
-const types_1 = require("../types");
-class CacheMemory {
-    constructor(options) {
-        this.embeddingModel = options.embeddingModel;
-        const ttlInHours = options.cacheTTL ?? 1;
-        this.CACHE_TTL = ttlInHours * 60 * 60;
-        this.CACHE_PREFIX = options.cachePrefix ?? "memory:";
-        this.redis = (0, redis_1.createClient)({
-            url: options.redisUrl || process.env.REDIS_URL,
-            socket: {
-                tls: true,
-                rejectUnauthorized: true,
-            },
-        });
-        this.initRedis();
-    }
-    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);
-        }
-    }
-    async storeMemory(memory, ttl) {
-        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, options = {}) {
-        console.log("\n🔍 Searching in cache");
-        console.log("Query:", query);
-        console.log("Options:", JSON.stringify(options, null, 2));
-        const { embedding } = await (0, ai_1.embed)({
-            model: openai_1.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 = (0, ai_1.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() {
-        const keys = await this.redis.keys(`${this.CACHE_PREFIX}*`);
-        const memories = await this.getMemoriesFromKeys(keys);
-        return memories;
-    }
-    async getMemoriesFromKeys(keys) {
-        const memories = [];
-        for (const key of keys) {
-            const data = await this.redis.get(key);
-            if (data) {
-                memories.push(JSON.parse(data));
-            }
-        }
-        return memories;
-    }
-    async createMemory(input) {
-        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;
-    }
-    async createSingleMemory(params) {
-        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 (0, ai_1.embed)({
-            model: this.embeddingModel,
-            value: params.query,
-        });
-        console.log("✅ Embedding generated successfully");
-        const memory = {
-            id: params.id,
-            data: params.data,
-            query: params.query,
-            embedding,
-            userId: params.userId,
-            scope: params.scope || (params.userId ? types_1.MemoryScope.USER : types_1.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;
-    }
-}
-exports.CacheMemory = CacheMemory;

package/dist/memory/persistent.d.ts

@@ -1,57 +0,0 @@
-import { EmbeddingModel } from "ai";
-import { LongTermMemory, MemoryScope } from "../types";
-interface SearchOptions {
-    scope?: MemoryScope;
-    userId?: string;
-    maxResults?: number;
-    similarityThreshold?: number;
-}
-interface ProcessedChunk {
-    content: string;
-    embedding: number[];
-}
-/**
- * Handles persistent memory storage using Meilisearch API
- */
-export declare class PersistentMemory {
-    private readonly host;
-    private readonly apiKey;
-    private readonly INDEX_PREFIX;
-    private readonly embeddingModel;
-    constructor(options: {
-        host: string;
-        apiKey: string;
-        indexPrefix?: string;
-        embeddingModel: EmbeddingModel<string>;
-    });
-    /**
-     * Initialize indexes
-     */
-    init(): Promise<void>;
-    /**
-     * Make API request to Meilisearch
-     */
-    private _makeRequest;
-    /**
-     * Get or create an index with proper settings
-     */
-    private _getOrCreateIndex;
-    processContent(content: string): Promise<ProcessedChunk[]>;
-    /**
-     * Store a memory in the database
-     */
-    createMemory(memory: LongTermMemory): Promise<unknown>;
-    /**
-     * Find best matching memories
-     */
-    findRelevantDocuments(query: string, options?: SearchOptions): Promise<{
-        query: string;
-        data: any;
-        createdAt: string;
-    }[]>;
-    /**
-     * Delete memories for a given scope and user
-     */
-    deleteMemories(): Promise<unknown>;
-}
-export {};