@ai.ntellect/core 0.0.24 → 0.0.26

package/dist/types.d.ts

@@ -0,0 +1,139 @@
+import { StreamTextResult } from "ai";
+import { z } from "zod";
+export interface BaseLLM {
+    process: (prompt: string) => Promise<string | object>;
+    streamProcess?: (prompt: string) => Promise<StreamTextResult<Record<string, any>>>;
+}
+export type User = {
+    id: string;
+};
+export interface QueueItem {
+    name: string;
+    parameters: QueueItemParameter[];
+}
+export interface IEventHandler {
+    emitQueueStart(actions: QueueItem[]): void;
+    emitActionStart(action: QueueItem): void;
+    emitActionComplete(action: QueueResult): void;
+    emitQueueComplete(): void;
+}
+export type AgentEvent = {
+    onMessage?: (data: any) => void;
+    onQueueStart?: (actions: QueueItem[]) => void;
+    onActionStart?: (action: QueueItem) => void;
+    onActionComplete?: (action: QueueResult) => void;
+    onQueueComplete?: (actions: QueueResult[]) => void;
+    onConfirmationRequired?: (message: string) => Promise<boolean>;
+};
+export interface QueueResult {
+    name: string;
+    parameters: Record<string, string>;
+    result: any;
+    error: string | null;
+    cancelled?: boolean;
+}
+export interface QueueCallbacks {
+    onActionStart?: (action: QueueItem) => void;
+    onActionComplete?: (result: QueueResult) => void;
+    onQueueComplete?: (results: QueueResult[]) => void;
+    onConfirmationRequired?: (message: string) => Promise<boolean>;
+}
+export interface ProcessPromptCallbacks {
+    onQueueStart?: (actions: QueueItem[]) => void | Promise<void>;
+    onActionStart?: (action: QueueItem) => void | Promise<void>;
+    onActionComplete?: (action: QueueResult) => void | Promise<void>;
+    onQueueComplete?: (actions: QueueResult[]) => void | Promise<void>;
+    onConfirmationRequired?: (message: string) => Promise<boolean>;
+}
+export interface ActionSchema {
+    name: string;
+    description: string;
+    parameters: z.ZodSchema;
+    execute: (args: any) => Promise<any>;
+    confirmation?: {
+        requireConfirmation: boolean;
+        message: string;
+    };
+}
+export type ProcessPromptResult = {
+    type: "success" | "clarification" | "confirmation";
+    data: QueueResult[] | {
+        validationErrors: string[];
+        prompt: string;
+    } | {
+        actions: QueueItem[];
+    };
+    initialPrompt: string;
+};
+export interface ActionPattern {
+    id: string;
+    actions: QueueResult[];
+    embeddings: number[][];
+    queries: string[];
+    purpose: string;
+}
+export interface MatchOptions {
+    similarityThreshold?: number;
+    maxResults?: number;
+}
+export interface MatchResult {
+    data: any;
+    similarityPercentage: number;
+    purpose: string;
+    name?: string;
+    parameters?: Record<string, any>;
+}
+export interface SummarizerAgent {
+    process: (results: object, onFinish?: (event: any) => void) => Promise<{
+        actions: {
+            name: string;
+            reasoning: string;
+        }[];
+        response: string;
+    } | StreamTextResult<Record<string, any>>>;
+    streamProcess: (results: object, onFinish?: (event: any) => void) => Promise<StreamTextResult<Record<string, any>>>;
+}
+export interface MemoryCacheOptions {
+    cacheTTL?: number;
+    redisUrl?: string;
+    cachePrefix?: string;
+}
+export interface CreateMemoryInput {
+    content: string;
+    type: MemoryType;
+    data: any;
+    userId?: string;
+    scope?: MemoryScope;
+}
+export interface Memory {
+    id: string;
+    type: MemoryType;
+    data: any;
+    purpose: string;
+    queries: string[];
+    embeddings: number[][];
+    userId?: string;
+    scope: MemoryScope;
+    createdAt: Date;
+}
+export declare enum MemoryType {
+    ACTION = "action",
+    CONVERSATION = "conversation",
+    KNOWLEDGE = "knowledge"
+}
+export declare enum MemoryScope {
+    GLOBAL = "global",
+    USER = "user"
+}
+export interface ActionData {
+    name?: string;
+    parameters?: Record<string, any>;
+}
+export interface QueueItemParameter {
+    name: string;
+    value: string;
+}
+export interface TransformedQueueItem {
+    name: string;
+    parameters: QueueItemParameter[];
+}

package/dist/utils/queue-item-transformer.d.ts

@@ -0,0 +1,7 @@
+import { ActionData, TransformedQueueItem } from "../types";
+export declare class QueueItemTransformer {
+    static transformActionToQueueItem(action: ActionData): TransformedQueueItem;
+    static transformFromSimilarActions(similarActions: any[]): TransformedQueueItem[] | undefined;
+    private static transformParameters;
+    static transformActionsToQueueItems(actions: ActionData[] | undefined): TransformedQueueItem[] | undefined;
+}

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

@@ -9,9 +9,8 @@ class QueueItemTransformer {
         };
     }
     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));
+        const firstMatch = similarActions?.[0]?.data;
+        return firstMatch?.map((action) => QueueItemTransformer.transformActionToQueueItem(action));
     }
     static transformParameters(parameters) {
         return Object.entries(parameters).map(([name, value]) => ({
@@ -20,7 +19,7 @@ class QueueItemTransformer {
         }));
     }
     static transformActionsToQueueItems(actions) {
-        return actions === null || actions === void 0 ? void 0 : actions.map(action => this.transformActionToQueueItem(action));
+        return actions?.map(action => this.transformActionToQueueItem(action));
     }
 }
 exports.QueueItemTransformer = QueueItemTransformer;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai.ntellect/core",
-  "version": "0.0.24",
+  "version": "0.0.26",
   "description": "",
   "main": "dist/index.js",
   "scripts": {

package/tsconfig.json

@@ -11,6 +11,5 @@
     "skipLibCheck": true,
     "forceConsistentCasingInFileNames": true
   },
-  "include": ["src/**/*", "test/**/*"],
-  "exclude": ["node_modules", "dist"]
+  "exclude": ["node_modules", "dist", "test"]
 }

package/dist/agents/orchestrator/index.js

@@ -1,40 +0,0 @@
-"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.Orchestrator = void 0;
-const openai_1 = require("@ai-sdk/openai");
-const ai_1 = require("ai");
-const zod_1 = require("zod");
-const context_1 = require("./context");
-class Orchestrator {
-    constructor(tools) {
-        this.model = (0, openai_1.openai)("gpt-4o-mini");
-        this.tools = tools;
-    }
-    process(prompt) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const response = yield (0, ai_1.generateObject)({
-                model: this.model,
-                schema: zod_1.z.object({
-                    actions: zod_1.z.array(zod_1.z.object({
-                        name: zod_1.z.string(),
-                        parameters: zod_1.z.record(zod_1.z.string(), zod_1.z.any()),
-                    })),
-                    answer: zod_1.z.string(),
-                }),
-                prompt: prompt,
-                system: context_1.orchestratorContext.compose(this.tools),
-            });
-            return response.object;
-        });
-    }
-}
-exports.Orchestrator = Orchestrator;

package/dist/agents/synthesizer/index.js

@@ -1,54 +0,0 @@
-"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.Summarizer = void 0;
-const openai_1 = require("@ai-sdk/openai");
-const ai_1 = require("ai");
-const zod_1 = require("zod");
-const context_1 = require("./context");
-class Summarizer {
-    constructor() {
-        this.model = (0, openai_1.openai)("gpt-4-turbo");
-    }
-    process(prompt, onFinish) {
-        return __awaiter(this, void 0, void 0, function* () {
-            console.log("Summarizing results...");
-            const result = yield (0, ai_1.generateObject)({
-                model: this.model,
-                schema: zod_1.z.object({
-                    actions: zod_1.z.array(zod_1.z.object({
-                        name: zod_1.z.string(),
-                        reasoning: zod_1.z.string(),
-                    })),
-                    response: zod_1.z.string(),
-                }),
-                prompt: context_1.summarizerContext.compose(prompt),
-                system: context_1.summarizerContext.role,
-            });
-            console.log("Summarized results:", result.object);
-            if (onFinish)
-                onFinish(result.object);
-            return result.object;
-        });
-    }
-    streamProcess(prompt, onFinish) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const result = yield (0, ai_1.streamText)({
-                model: this.model,
-                prompt: context_1.summarizerContext.compose(prompt),
-                onFinish: onFinish,
-                system: context_1.summarizerContext.role,
-            });
-            return result;
-        });
-    }
-}
-exports.Summarizer = Summarizer;

package/dist/workflow/index.js

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