@ai.ntellect/core 0.0.1

package/dist/utils/queue-item-transformer.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueueItemTransformer = void 0;
+class QueueItemTransformer {
+    static transformActionToQueueItem(action) {
+        return {
+            name: action.name || '',
+            parameters: QueueItemTransformer.transformParameters(action.parameters || {})
+        };
+    }
+    static transformFromSimilarActions(similarActions) {
+        var _a;
+        const firstMatch = (_a = similarActions === null || similarActions === void 0 ? void 0 : similarActions[0]) === null || _a === void 0 ? void 0 : _a.data;
+        return firstMatch === null || firstMatch === void 0 ? void 0 : firstMatch.map((action) => QueueItemTransformer.transformActionToQueueItem(action));
+    }
+    static transformParameters(parameters) {
+        return Object.entries(parameters).map(([name, value]) => ({
+            name,
+            value: typeof value === 'object' ? JSON.stringify(value) : String(value)
+        }));
+    }
+    static transformActionsToQueueItems(actions) {
+        return actions === null || actions === void 0 ? void 0 : actions.map(action => this.transformActionToQueueItem(action));
+    }
+}
+exports.QueueItemTransformer = QueueItemTransformer;

package/dist/workflow/index.js

@@ -0,0 +1,187 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Workflow = void 0;
+const synthesizer_1 = require("../agents/synthesizer");
+const queue_1 = require("../services/queue");
+const types_1 = require("../types");
+const queue_item_transformer_1 = require("../utils/queue-item-transformer");
+class Workflow {
+    constructor(user, dependencies) {
+        this.user = user;
+        this.dependencies = dependencies;
+        this.CONFIRMATION_TIMEOUT = 5 * 60 * 1000; // 5 minutes
+        this.SIMILARITY_THRESHOLD = 95;
+        this.MAX_RESULTS = 1;
+    }
+    start(prompt, promptWithContext, stream) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const request = yield this.dependencies.orchestrator.process(promptWithContext);
+            this.dependencies.eventEmitter.emit("orchestrator-update", {
+                type: "on-message",
+                data: request,
+            });
+            if (request.actions.length > 0) {
+                return this.handleActions(prompt, request.actions);
+            }
+        });
+    }
+    handleActions(prompt, actions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let predefinedActions = actions;
+            console.log("\n🔍 Predefined actions:", predefinedActions);
+            const similarActions = yield this.dependencies.memoryCache.findBestMatches(prompt, {
+                similarityThreshold: this.SIMILARITY_THRESHOLD,
+                maxResults: this.MAX_RESULTS,
+                userId: this.user.id,
+                scope: types_1.MemoryScope.USER,
+            });
+            console.log("\n🔍 Similar actions:", similarActions);
+            predefinedActions =
+                queue_item_transformer_1.QueueItemTransformer.transformActionsToQueueItems(predefinedActions) ||
+                    [];
+            console.log("\n🔍 Transformed predefined actions:", predefinedActions);
+            if (similarActions && similarActions.length > 0) {
+                predefinedActions =
+                    queue_item_transformer_1.QueueItemTransformer.transformFromSimilarActions(similarActions) || [];
+                console.log("\n🔍 Transformed similar actions:", predefinedActions);
+            }
+            console.log("\n🔍 Final actions:", predefinedActions);
+            const callbacks = this.createCallbacks(prompt, similarActions);
+            console.log("\n🔍 Queue prepared");
+            const actionsResult = yield this.executeActions(predefinedActions, this.dependencies.orchestrator.tools, callbacks);
+            console.log("\n🔍 Actions result:", actionsResult);
+            return this.handleActionResults(Object.assign(Object.assign({}, actionsResult), { initialPrompt: prompt }), prompt);
+        });
+    }
+    executeActions(predefinedActions, tools, callbacks) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const queueManager = new queue_1.ActionQueueManager(tools, {
+                    onActionStart: callbacks === null || callbacks === void 0 ? void 0 : callbacks.onActionStart,
+                    onActionComplete: callbacks === null || callbacks === void 0 ? void 0 : callbacks.onActionComplete,
+                    onQueueComplete: callbacks === null || callbacks === void 0 ? void 0 : callbacks.onQueueComplete,
+                    onConfirmationRequired: (message) => __awaiter(this, void 0, void 0, function* () {
+                        if (callbacks === null || callbacks === void 0 ? void 0 : callbacks.onConfirmationRequired) {
+                            return yield callbacks.onConfirmationRequired(message);
+                        }
+                        return false;
+                    }),
+                });
+                queueManager.addToQueue(predefinedActions);
+                if (callbacks === null || callbacks === void 0 ? void 0 : callbacks.onQueueStart) {
+                    callbacks.onQueueStart(predefinedActions);
+                }
+                console.log("Processing queue...");
+                const results = yield queueManager.processQueue();
+                console.log("Queue completed:");
+                console.dir(results, { depth: null });
+                return {
+                    type: "success",
+                    data: results || [],
+                };
+            }
+            catch (error) {
+                console.error("Error processing prompt:", error);
+                throw error;
+            }
+        });
+    }
+    createCallbacks(prompt, similarActions) {
+        return {
+            onQueueStart: (actions) => __awaiter(this, void 0, void 0, function* () {
+                console.dir(actions, { depth: null });
+                this.dependencies.eventEmitter.emit("orchestrator-update", {
+                    type: "queue-start",
+                    actions,
+                });
+            }),
+            onActionStart: (action) => {
+                this.dependencies.eventEmitter.emit("orchestrator-update", {
+                    type: "action-start",
+                    action: action.name,
+                    args: action.parameters,
+                });
+            },
+            onActionComplete: (action) => {
+                this.dependencies.eventEmitter.emit("orchestrator-update", {
+                    type: "action-complete",
+                    action: action.name,
+                    result: action.result,
+                });
+            },
+            onQueueComplete: (actions) => __awaiter(this, void 0, void 0, function* () {
+                if (!similarActions.length) {
+                    yield this.saveToMemory(prompt, actions);
+                }
+                this.dependencies.eventEmitter.emit("orchestrator-update", {
+                    type: "queue-complete",
+                });
+            }),
+            onConfirmationRequired: this.handleConfirmationRequest.bind(this),
+        };
+    }
+    handleConfirmationRequest(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve) => {
+                const confirmationId = Date.now().toString();
+                const handleConfirmation = (data) => {
+                    if (data.confirmationId === confirmationId) {
+                        this.dependencies.eventEmitter.removeListener("confirmation-response", handleConfirmation);
+                        resolve(data.confirmed);
+                    }
+                };
+                this.dependencies.eventEmitter.once("confirmation-response", handleConfirmation);
+                this.dependencies.eventEmitter.emit("orchestrator-update", {
+                    type: "confirmation-required",
+                    id: confirmationId,
+                    message,
+                });
+                setTimeout(() => {
+                    this.dependencies.eventEmitter.removeListener("confirmation-response", handleConfirmation);
+                    resolve(false);
+                }, this.CONFIRMATION_TIMEOUT);
+            });
+        });
+    }
+    saveToMemory(prompt, actions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log("\n🔍 Creating memory...");
+            yield this.dependencies.memoryCache.createMemory({
+                content: prompt,
+                userId: this.user.id,
+                scope: types_1.MemoryScope.USER,
+                type: types_1.MemoryType.ACTION,
+                data: actions,
+            });
+        });
+    }
+    handleActionResults(actionsResult_1, prompt_1) {
+        return __awaiter(this, arguments, void 0, function* (actionsResult, prompt, stream = true) {
+            if (!this.hasNonPrepareActions(actionsResult.data)) {
+                return;
+            }
+            const summarizer = new synthesizer_1.Summarizer();
+            const summaryData = JSON.stringify({
+                result: actionsResult.data,
+                initialPrompt: prompt,
+            });
+            return stream
+                ? (yield summarizer.streamProcess(summaryData)).toDataStreamResponse()
+                : yield summarizer.process(summaryData);
+        });
+    }
+    hasNonPrepareActions(actions) {
+        return (Array.isArray(actions) &&
+            actions.some((action) => { var _a; return ((_a = action.name) === null || _a === void 0 ? void 0 : _a.split("-")[0]) !== "prepare"; }));
+    }
+}
+exports.Workflow = Workflow;

package/index.ts

@@ -0,0 +1,7 @@
+export * from "./agents/orchestrator";
+export * from "./agents/synthesizer";
+export * from "./services/queue";
+export * from "./types";
+
+export * from "./memory";
+export * from "./workflow";

package/memory/index.ts

@@ -0,0 +1,201 @@
+import { openai } from "@ai-sdk/openai";
+import { cosineSimilarity, embed, embedMany, generateObject } from "ai";
+import { createClient } from 'redis';
+import { z } from "zod";
+import { CreateMemoryInput, MatchOptions, Memory, MemoryCacheOptions, MemoryScope } from "../types";
+
+export class MemoryCache {
+  private redis;
+  private readonly CACHE_PREFIX: string;
+  private readonly CACHE_TTL: number;
+
+  constructor(options: MemoryCacheOptions = {}) {
+    const ttlInHours = options.cacheTTL ?? 1;
+    this.CACHE_TTL = ttlInHours * 60 * 60;
+    this.CACHE_PREFIX = options.cachePrefix ?? 'memory:';
+    
+    this.redis = createClient({
+      url: options.redisUrl || process.env.REDIS_URL,
+      socket: {
+        tls: true,
+        rejectUnauthorized: true
+      }
+    });
+    this.initRedis();
+  }
+
+  private async initRedis() {
+    this.redis.on('error', err => {
+      console.error('Redis Client Error:', err);
+      // Implement retry logic if needed
+    });
+    
+    try {
+      await this.redis.connect();
+      console.log('Successfully connected to Redis');
+    } catch (error) {
+      console.error('Failed to connect to Redis:', error);
+      // Handle connection failure
+    }
+  }
+
+  private getMemoryKey(scope: MemoryScope, userId?: string): string {
+    if (scope === MemoryScope.GLOBAL) {
+      return `${this.CACHE_PREFIX}global:`;
+    }
+    return `${this.CACHE_PREFIX}user:${userId}:`;
+  }
+
+  private async storeMemory(memory: Memory) {
+    const prefix = this.getMemoryKey(memory.scope, memory.userId);
+    const key = `${prefix}${memory.id}`;
+    await this.redis.set(key, JSON.stringify(memory), {
+      EX: this.CACHE_TTL
+    });
+  }
+
+  async findBestMatches(
+    query: string, 
+    options: MatchOptions & { userId?: string; scope?: MemoryScope } = {}
+  ): Promise<{
+    data: any;
+    similarityPercentage: number;
+    purpose: string;
+  }[]> {
+    console.log("\n🔍 Searching for query:", query);
+
+    const { embedding } = await embed({
+      model: openai.embedding("text-embedding-3-small"),
+      value: query
+    });
+
+    const memories = await this.getAllMemories(options.scope, options.userId);
+    console.log("\n📚 Found", memories.length, "memories to compare with");
+
+    const matches = memories
+      .map(memory => {
+        const similarities = memory.embeddings.map(emb => {
+          const similarity = cosineSimilarity(embedding, emb);
+         
+          return (similarity + 1) * 50; // Convert to percentage
+        });
+
+        const maxSimilarity = Math.max(...similarities);
+        console.log(`\n📊 Memory "${memory.purpose}":
+          - Similarity: ${maxSimilarity.toFixed(2)}%
+          - Original queries: ${memory.queries.join(", ")}`);
+
+        return {
+          data: memory.data,
+          similarityPercentage: maxSimilarity,
+          purpose: memory.purpose,
+        };
+      })
+      .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✨ Best matches found:");
+      results.forEach(match => {
+        console.log(`- ${match.purpose} (${match.similarityPercentage.toFixed(2)}%)`);
+      });
+    } else {
+      console.log("No matches found");
+    }
+
+    console.dir({results});
+    return results;
+  }
+
+  private async getAllMemories(scope?: MemoryScope, userId?: string): Promise<Memory[]> {
+    let patterns: Memory[] = [];
+
+    if (!scope || scope === MemoryScope.GLOBAL) {
+      const globalPrefix = this.getMemoryKey(MemoryScope.GLOBAL);
+      const globalKeys = await this.redis.keys(`${globalPrefix}*`);
+      const globalPatterns = await this.getMemoriesFromKeys(globalKeys);
+      patterns = patterns.concat(globalPatterns);
+    }
+
+    if (userId && (!scope || scope === MemoryScope.USER)) {
+      const userPrefix = this.getMemoryKey(MemoryScope.USER, userId);
+      const userKeys = await this.redis.keys(`${userPrefix}*`);
+      const userPatterns = await this.getMemoriesFromKeys(userKeys);
+      patterns = patterns.concat(userPatterns);
+    }
+
+    return patterns;
+  }
+
+  private async getMemoriesFromKeys(keys: string[]): Promise<Memory[]> {
+    const memories: Memory[] = [];
+    for (const key of keys) {
+      const data = await this.redis.get(key);
+      if (data) {
+        memories.push(JSON.parse(data));
+      }
+    }
+    return memories;
+  }
+
+  public async createMemory(input: CreateMemoryInput): Promise<string | undefined> {
+    const { embedding } = await embed({
+      model: openai.embedding("text-embedding-3-small"),
+      value: input.content
+    });
+
+    const existingPattern = await this.findBestMatches(input.content, {
+      similarityThreshold: 95,
+      userId: input.userId,
+      scope: input.scope
+    });
+
+    if (existingPattern.length > 0) {
+      console.log("\n🔍 Similar memory found:");
+      // Display only the name and similarity percentage
+      existingPattern.forEach(match => {
+        console.log(`- ${match.purpose} (${match.similarityPercentage.toFixed(2)}%)`);
+      });
+      return;
+    }
+
+    const variations = await generateObject({
+      model: openai("gpt-4"),
+      schema: z.object({
+        request: z.string().describe("The request to be performed"),
+        queries: z.array(z.object({
+              text: z.string()
+        }))
+      }),
+      prompt: `For this input: "${input.content}"
+        Generate similar variations that should match the same context.
+        Context type: ${input.type}
+        Data: ${JSON.stringify(input.data)}
+        - Keep variations natural and human-like
+        - Include the original input
+        - Add 3-5 variations`
+    });
+
+    const embeddingResults = await embedMany({
+      model: openai.embedding("text-embedding-3-small"),
+      values: variations.object.queries.map(q => q.text)
+    });
+
+    const memory: Memory = {
+      id: crypto.randomUUID(),
+      type: input.type,
+      data: input.data,
+      purpose: variations.object.request,
+      queries: [input.content, ...variations.object.queries.map(q => q.text)],
+      embeddings: [embedding, ...embeddingResults.embeddings],
+      userId: input.userId,
+      scope: input.scope || (input.userId ? MemoryScope.USER : MemoryScope.GLOBAL),
+      createdAt: new Date()
+    };
+    
+    await this.storeMemory(memory);
+    return variations.object.request;
+  }
+}

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@ai.ntellect/core",
+  "version": "0.0.1",
+  "description": "",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "rm -rf dist && tsc",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "Lorcann Rauzduel",
+  "license": "ISC",
+  "dependencies": {
+    "@ai-sdk/openai": "1.0.6",
+    "ai": "^3.0.0",
+    "redis": "^4.7.0",
+    "zod": "^3.24.1"
+  },
+  "devDependencies": {
+    "typescript": "^5.7.2"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ai.ntellect/core.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ai.ntellect/core/issues"
+  },
+  "homepage": "https://github.com/ai.ntellect/core#readme"
+}

package/services/queue.ts

@@ -0,0 +1,147 @@
+import {
+  ActionSchema,
+  QueueCallbacks,
+  QueueItem,
+  QueueItemParameter,
+  QueueResult,
+} from "../types";
+
+export class ActionQueueManager {
+  private queue: QueueItem[] = [];
+  private results: QueueResult[] = [];
+  private callbacks: QueueCallbacks;
+  private actions: ActionSchema[];
+  private isProcessing: boolean = false;
+
+  constructor(actions: ActionSchema[], callbacks: QueueCallbacks = {}) {
+    this.actions = actions;
+    this.callbacks = callbacks;
+  }
+
+  addToQueue(actions: QueueItem | QueueItem[]) {
+    if (Array.isArray(actions)) {
+      console.log(
+        "Adding actions to queue:",
+        actions.map((a) => a.name).join(", ")
+      );
+      this.queue.push(...actions);
+    } else {
+      console.log("Adding action to queue:", actions.name);
+      this.queue.push(actions);
+    }
+  }
+
+  async processQueue() {
+    if (this.isProcessing) {
+      console.warn("Queue is already being processed");
+      return;
+    }
+
+    this.isProcessing = true;
+    const actionPromises = [];
+
+    for (const action of this.queue) {
+      const actionConfig = this.actions.find((a) => a.name === action.name);
+
+      if (actionConfig?.confirmation?.requireConfirmation) {
+        // Wait for user confirmation before executing this action
+        const shouldProceed = await this.callbacks.onConfirmationRequired?.(
+          actionConfig.confirmation.message ||
+            `Do you want to proceed with action: ${action.name}?`
+        );
+
+        if (!shouldProceed) {
+          // Skip this action and add a cancelled result
+          this.results.push({
+            name: action.name,
+            parameters: this.formatArguments(action.parameters),
+            result: null,
+            error: "Action cancelled by user",
+            cancelled: true,
+          });
+          continue;
+        }
+      }
+
+      actionPromises.push(
+        this.executeAction(action)
+          .then((result) => {
+            this.callbacks.onActionComplete?.(result);
+            return result;
+          })
+          .catch((error) => {
+            const result = {
+              name: action.name,
+              parameters: this.formatArguments(action.parameters),
+              result: null,
+              error: error.message || "Unknown error occurred",
+            };
+            this.callbacks.onActionComplete?.(result);
+            return result;
+          })
+      );
+    }
+
+    try {
+      const results = await Promise.all(actionPromises);
+      this.results.push(...results);
+      this.queue = [];
+      this.callbacks.onQueueComplete?.(this.results);
+      this.isProcessing = false;
+      return this.results;
+    } catch (error) {
+      this.isProcessing = false;
+      console.error("Unexpected error in queue processing:", error);
+      throw error;
+    }
+  }
+
+  private formatArguments(args: QueueItemParameter[]): Record<string, string> {
+    return args.reduce<Record<string, string>>((acc, arg) => {
+      acc[arg.name] = arg.value;
+      return acc;
+    }, {});
+  }
+
+  private async executeAction(action: QueueItem): Promise<QueueResult> {
+    // Call onActionStart callback
+    this.callbacks.onActionStart?.(action);
+    const actionConfig = this.actions.find((a) => a.name === action.name);
+    if (!actionConfig) {
+      return {
+        name: action.name,
+        parameters: {},
+        result: null,
+        error: `Action '${action.name}' not found in actions list`,
+      };
+    }
+
+    const actionArgs = action.parameters.reduce<Record<string, string>>(
+      (acc: Record<string, string>, arg: QueueItemParameter) => {
+        acc[arg.name] = arg.value;
+        return acc;
+      },
+      {}
+    );
+
+    console.log(`Executing ${action.name} with args:`, actionArgs);
+
+    try {
+      const result = await actionConfig.execute(actionArgs);
+      return {
+        name: action.name,
+        parameters: actionArgs,
+        result,
+        error: null,
+      };
+    } catch (error) {
+      console.error(`Error executing action ${action.name}:`, error);
+      return {
+        name: action.name,
+        parameters: actionArgs,
+        result: null,
+        error: (error as Error).message || "Unknown error occurred",
+      };
+    }
+  }
+}