@ai.ntellect/core 0.5.0 → 0.6.0

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

package/dist/memory/persistent.js

@@ -1,189 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PersistentMemory = void 0;
-const ai_1 = require("ai");
-const text_splitter_1 = require("langchain/text_splitter");
-/**
- * Handles persistent memory storage using Meilisearch API
- */
-class PersistentMemory {
-    constructor(options) {
-        this.host = options.host;
-        this.apiKey = options.apiKey;
-        this.INDEX_PREFIX = options.indexPrefix || "memory";
-        this.embeddingModel = options.embeddingModel;
-    }
-    /**
-     * Initialize indexes
-     */
-    async init() {
-        try {
-            // Create or get main index
-            await this._getOrCreateIndex(this.INDEX_PREFIX);
-            console.log(`✅ Index '${this.INDEX_PREFIX}' initialized successfully`);
-        }
-        catch (error) {
-            console.error(`❌ Failed to initialize index: ${error}`);
-            throw error;
-        }
-    }
-    /**
-     * Make API request to Meilisearch
-     */
-    async _makeRequest(path, options = {}) {
-        const url = `${this.host}${path}`;
-        console.log("🔍 Making request to Meilisearch:", url);
-        const response = await fetch(url, {
-            ...options,
-            headers: {
-                "Content-Type": "application/json",
-                Authorization: `Bearer ${this.apiKey}`,
-                ...options.headers,
-            },
-        });
-        if (!response.ok) {
-            console.log({ response });
-            throw new Error(`Meilisearch API error: ${response.statusText}`);
-        }
-        return response.json();
-    }
-    /**
-     * Get or create an index with proper settings
-     */
-    async _getOrCreateIndex(indexName) {
-        try {
-            // Check if index exists first
-            const indexExists = await this._makeRequest(`/indexes/${indexName}`, {
-                method: "GET",
-            }).catch(() => false);
-            if (!indexExists) {
-                console.log(`Creating new index: ${indexName}`);
-                await this._makeRequest("/indexes", {
-                    method: "POST",
-                    body: JSON.stringify({
-                        uid: indexName,
-                        primaryKey: "id",
-                    }),
-                });
-            }
-            // Update index settings
-            const settings = {
-                searchableAttributes: ["query", "purpose", "chunks.content"],
-                sortableAttributes: ["createdAt"],
-            };
-            await this._makeRequest(`/indexes/${indexName}/settings`, {
-                method: "PATCH",
-                body: JSON.stringify(settings),
-            });
-            console.log(`Index ${indexName} configured successfully`);
-        }
-        catch (error) {
-            console.error(`Failed to configure index ${indexName}:`, error);
-            throw error;
-        }
-    }
-    async processContent(content) {
-        // Split content into chunks
-        const textSplitter = new text_splitter_1.RecursiveCharacterTextSplitter({
-            chunkSize: 1000,
-        });
-        const chunks = await textSplitter.createDocuments([content]);
-        // Generate embeddings for all chunks
-        const { embeddings } = await (0, ai_1.embedMany)({
-            model: this.embeddingModel,
-            values: chunks.map((chunk) => chunk.pageContent),
-        });
-        // Create processed chunks with embeddings
-        return chunks.map((chunk, i) => ({
-            content: chunk.pageContent,
-            embedding: embeddings[i],
-        }));
-    }
-    /**
-     * Store a memory in the database
-     */
-    async createMemory(memory) {
-        try {
-            console.log(`📝 Creating memory in index: ${this.INDEX_PREFIX}`);
-            // Process content into chunks with embeddings
-            const chunks = await this.processContent(memory.data);
-            // Generate unique ID if not provided
-            const id = memory.id || crypto.randomUUID();
-            const document = {
-                ...memory,
-                chunks,
-                createdAt: memory.createdAt.toISOString(),
-            };
-            const response = await this._makeRequest(`/indexes/${this.INDEX_PREFIX}/documents`, {
-                method: "POST",
-                body: JSON.stringify([document]),
-            });
-            console.log("✅ Memory created successfully", { id });
-            return response;
-        }
-        catch (error) {
-            console.error("❌ Failed to create memory:", error);
-            throw error;
-        }
-    }
-    /**
-     * Find best matching memories
-     */
-    async findRelevantDocuments(query, options = {}) {
-        console.log(`\n🔍 Searching in index: ${this.INDEX_PREFIX}`);
-        console.log("Query:", query);
-        try {
-            // Generate embedding for the query
-            const { embedding: queryEmbedding } = await (0, ai_1.embed)({
-                model: this.embeddingModel,
-                value: query,
-            });
-            // Search in the index
-            const searchResults = await this._makeRequest(`/indexes/${this.INDEX_PREFIX}/search`, {
-                method: "POST",
-                body: JSON.stringify({
-                    q: query,
-                    limit: options.maxResults || 10,
-                }),
-            });
-            if (!searchResults?.hits?.length) {
-                console.log("❌ No matches found");
-                return [];
-            }
-            // Process and filter results using cosine similarity
-            const results = searchResults.hits
-                .flatMap((hit) => {
-                const chunkSimilarities = hit.chunks.map((chunk) => ({
-                    query: hit.query,
-                    data: hit.data,
-                    similarityPercentage: ((0, ai_1.cosineSimilarity)(queryEmbedding, chunk.embedding) + 1) * 50,
-                    createdAt: hit.createdAt,
-                }));
-                return chunkSimilarities.reduce((best, current) => current.similarityPercentage > best.similarityPercentage
-                    ? current
-                    : best, chunkSimilarities[0]);
-            })
-                .filter((match) => match.similarityPercentage >= (options.similarityThreshold || 70))
-                .sort((a, b) => b.similarityPercentage - a.similarityPercentage);
-            console.log(`✨ Found ${results.length} relevant matches`);
-            return results.map((result) => ({
-                query: result.query,
-                data: result.data,
-                createdAt: result.createdAt,
-            }));
-        }
-        catch (error) {
-            console.error("❌ Search failed:", error);
-            return [];
-        }
-    }
-    /**
-     * Delete memories for a given scope and user
-     */
-    async deleteMemories() {
-        return this._makeRequest(`/indexes/${this.INDEX_PREFIX}`, {
-            method: "DELETE",
-        });
-    }
-}
-exports.PersistentMemory = PersistentMemory;

package/dist/services/queue.d.ts

@@ -1,13 +0,0 @@
-import { ActionSchema, QueueCallbacks, QueueItem, QueueResult } from "../types";
-export declare class ActionQueueManager {
-    private queue;
-    private results;
-    private callbacks;
-    private actions;
-    private isProcessing;
-    constructor(actions: ActionSchema[], callbacks?: QueueCallbacks);
-    addToQueue(actions: QueueItem | QueueItem[]): void;
-    processQueue(): Promise<QueueResult[] | undefined>;
-    private formatArguments;
-    private executeAction;
-}

package/dist/services/redis-cache.d.ts

@@ -1,37 +0,0 @@
-export interface CacheConfig {
-    host: string;
-    port: number;
-    password?: string;
-    ttl?: number;
-    cleanupInterval?: string;
-}
-export declare class RedisCache {
-    private redis;
-    private readonly defaultTTL;
-    private readonly cleanupJob;
-    constructor(config: CacheConfig);
-    /**
-     * Store previous actions for a specific request
-     */
-    storePreviousActions(requestId: string, actions: any[]): Promise<void>;
-    /**
-     * Get previous actions for a specific request
-     */
-    getPreviousActions(requestId: string): Promise<any[]>;
-    /**
-     * Store a recent message
-     */
-    storeRecentMessage(message: string, metadata?: Record<string, any>): Promise<void>;
-    /**
-     * Get recent messages
-     */
-    getRecentMessages(limit?: number): Promise<any[]>;
-    /**
-     * Cleanup expired keys
-     */
-    private cleanup;
-    /**
-     * Stop the cleanup job and close Redis connection
-     */
-    close(): Promise<void>;
-}