@ai.ntellect/core 0.0.24 → 0.0.26

package/dist/agent/handlers/ActionHandler.d.ts

@@ -0,0 +1,8 @@
+import { ActionSchema, ProcessPromptCallbacks, QueueItem, QueueResult } from "../../types";
+export declare class ActionHandler {
+    executeActions(predefinedActions: QueueItem[], tools: ActionSchema[], callbacks?: ProcessPromptCallbacks): Promise<{
+        type: string;
+        data: QueueResult[];
+    }>;
+    hasNonPrepareActions(actions: QueueResult[]): boolean;
+}

package/dist/agent/handlers/ActionHandler.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActionHandler = void 0;
+const queue_1 = require("../../services/queue");
+class ActionHandler {
+    async executeActions(predefinedActions, tools, callbacks) {
+        try {
+            const queueManager = new queue_1.ActionQueueManager(tools, {
+                onActionStart: callbacks?.onActionStart,
+                onActionComplete: callbacks?.onActionComplete,
+                onQueueComplete: callbacks?.onQueueComplete,
+                onConfirmationRequired: async (message) => {
+                    if (callbacks?.onConfirmationRequired) {
+                        return await callbacks.onConfirmationRequired(message);
+                    }
+                    return false;
+                },
+            });
+            queueManager.addToQueue(predefinedActions);
+            if (callbacks?.onQueueStart) {
+                callbacks.onQueueStart(predefinedActions);
+            }
+            const results = await queueManager.processQueue();
+            return { type: "success", data: results || [] };
+        }
+        catch (error) {
+            console.error("Error processing prompt:", error);
+            throw error;
+        }
+    }
+    hasNonPrepareActions(actions) {
+        return (Array.isArray(actions) &&
+            actions.some((action) => action.name?.split("-")[0] !== "prepare"));
+    }
+}
+exports.ActionHandler = ActionHandler;

package/dist/agent/handlers/ConfirmationHandler.d.ts

@@ -0,0 +1,7 @@
+import EventEmitter from "events";
+export declare class ConfirmationHandler {
+    private readonly eventEmitter;
+    private readonly CONFIRMATION_TIMEOUT;
+    constructor(eventEmitter: EventEmitter);
+    handleConfirmationRequest(message: string): Promise<boolean>;
+}

package/dist/agent/handlers/ConfirmationHandler.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfirmationHandler = void 0;
+class ConfirmationHandler {
+    constructor(eventEmitter) {
+        this.eventEmitter = eventEmitter;
+        this.CONFIRMATION_TIMEOUT = 5 * 60 * 1000; // 5 minutes
+    }
+    async handleConfirmationRequest(message) {
+        return new Promise((resolve) => {
+            const confirmationId = Date.now().toString();
+            const handleConfirmation = (data) => {
+                if (data.confirmationId === confirmationId) {
+                    this.eventEmitter.removeListener("confirmation-response", handleConfirmation);
+                    resolve(data.confirmed);
+                }
+            };
+            this.eventEmitter.once("confirmation-response", handleConfirmation);
+            this.eventEmitter.emit("orchestrator-update", {
+                type: "confirmation-required",
+                id: confirmationId,
+                message,
+            });
+            setTimeout(() => {
+                this.eventEmitter.removeListener("confirmation-response", handleConfirmation);
+                resolve(false);
+            }, this.CONFIRMATION_TIMEOUT);
+        });
+    }
+}
+exports.ConfirmationHandler = ConfirmationHandler;

package/dist/agent/handlers/EventHandler.d.ts

@@ -0,0 +1,10 @@
+import EventEmitter from "events";
+import { IEventHandler, QueueItem, QueueResult } from "../../types";
+export declare class EventHandler implements IEventHandler {
+    private readonly eventEmitter;
+    constructor(eventEmitter: EventEmitter);
+    emitQueueStart(actions: QueueItem[]): void;
+    emitActionStart(action: QueueItem): void;
+    emitActionComplete(action: QueueResult): void;
+    emitQueueComplete(): void;
+}

package/dist/agent/handlers/EventHandler.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventHandler = void 0;
+class EventHandler {
+    constructor(eventEmitter) {
+        this.eventEmitter = eventEmitter;
+    }
+    emitQueueStart(actions) {
+        this.eventEmitter.emit("orchestrator-update", {
+            type: "queue-start",
+            actions,
+        });
+    }
+    emitActionStart(action) {
+        this.eventEmitter.emit("orchestrator-update", {
+            type: "action-start",
+            action: action.name,
+            args: action.parameters,
+        });
+    }
+    emitActionComplete(action) {
+        this.eventEmitter.emit("orchestrator-update", {
+            type: "action-complete",
+            action: action.name,
+            result: action.result,
+        });
+    }
+    emitQueueComplete() {
+        this.eventEmitter.emit("orchestrator-update", {
+            type: "queue-complete",
+        });
+    }
+}
+exports.EventHandler = EventHandler;

package/dist/agent/index.d.ts

@@ -0,0 +1,22 @@
+import EventEmitter from "events";
+import { Orchestrator } from "../llm/orchestrator";
+import { MemoryCache } from "../memory";
+import { AgentEvent, User } from "../types";
+export declare class Agent {
+    private readonly user;
+    private readonly dependencies;
+    private readonly stream;
+    private readonly SIMILARITY_THRESHOLD;
+    private readonly MAX_RESULTS;
+    private readonly actionHandler;
+    constructor(user: User, dependencies: {
+        orchestrator: Orchestrator;
+        memoryCache: MemoryCache;
+        eventEmitter: EventEmitter;
+    }, stream?: boolean);
+    start(prompt: string, contextualizedPrompt: string, events: AgentEvent): Promise<any>;
+    private handleActions;
+    private findSimilarActions;
+    private transformActions;
+    private handleActionResults;
+}

package/dist/agent/index.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Agent = void 0;
+const synthesizer_1 = require("../llm/synthesizer");
+const types_1 = require("../types");
+const queue_item_transformer_1 = require("../utils/queue-item-transformer");
+const ActionHandler_1 = require("./handlers/ActionHandler");
+class Agent {
+    constructor(user, dependencies, stream = true) {
+        this.user = user;
+        this.dependencies = dependencies;
+        this.stream = stream;
+        this.SIMILARITY_THRESHOLD = 95;
+        this.MAX_RESULTS = 1;
+        this.actionHandler = new ActionHandler_1.ActionHandler();
+    }
+    async start(prompt, contextualizedPrompt, events) {
+        const request = await this.dependencies.orchestrator.process(contextualizedPrompt);
+        events.onMessage?.(request);
+        if (request.actions.length > 0) {
+            return this.handleActions({
+                initialPrompt: prompt,
+                actions: request.actions,
+            }, events);
+        }
+    }
+    async handleActions({ initialPrompt, actions, }, events) {
+        const similarActions = await this.findSimilarActions(initialPrompt);
+        const predefinedActions = this.transformActions(actions, similarActions);
+        const callbacks = {
+            onQueueStart: events.onQueueStart,
+            onActionStart: events.onActionStart,
+            onActionComplete: events.onActionComplete,
+            onQueueComplete: events.onQueueComplete,
+            onConfirmationRequired: events.onConfirmationRequired,
+        };
+        const actionsResult = await this.actionHandler.executeActions(predefinedActions, this.dependencies.orchestrator.tools, callbacks);
+        if (!this.actionHandler.hasNonPrepareActions(actionsResult.data)) {
+            return {
+                data: actionsResult.data,
+                initialPrompt,
+            };
+        }
+        return this.handleActionResults({ ...actionsResult, initialPrompt });
+    }
+    async findSimilarActions(prompt) {
+        return this.dependencies.memoryCache.findBestMatches(prompt, {
+            similarityThreshold: this.SIMILARITY_THRESHOLD,
+            maxResults: this.MAX_RESULTS,
+            userId: this.user.id,
+            scope: types_1.MemoryScope.USER,
+        });
+    }
+    transformActions(actions, similarActions) {
+        let predefinedActions = queue_item_transformer_1.QueueItemTransformer.transformActionsToQueueItems(actions) || [];
+        if (similarActions?.length > 0) {
+            predefinedActions =
+                queue_item_transformer_1.QueueItemTransformer.transformFromSimilarActions(similarActions) || [];
+        }
+        return predefinedActions;
+    }
+    async handleActionResults(actionsResult) {
+        const summarizer = new synthesizer_1.Summarizer();
+        const summaryData = JSON.stringify({
+            result: actionsResult.data,
+            initialPrompt: actionsResult.initialPrompt,
+        });
+        return this.stream
+            ? (await summarizer.streamProcess(summaryData)).toDataStreamResponse()
+            : await summarizer.process(summaryData);
+    }
+}
+exports.Agent = Agent;

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./agent";
+export * from "./llm/orchestrator";
+export * from "./llm/synthesizer";
+export * from "./services/queue";
+export * from "./types";
+export * from "./memory";

package/dist/index.js

@@ -14,9 +14,9 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./agents/orchestrator"), exports);
-__exportStar(require("./agents/synthesizer"), exports);
+__exportStar(require("./agent"), exports);
+__exportStar(require("./llm/orchestrator"), exports);
+__exportStar(require("./llm/synthesizer"), exports);
 __exportStar(require("./services/queue"), exports);
 __exportStar(require("./types"), exports);
 __exportStar(require("./memory"), exports);
-__exportStar(require("./workflow"), exports);

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

@@ -0,0 +1,8 @@
+import { ActionSchema } from "../../types";
+export declare const orchestratorContext: {
+    role: string;
+    guidelines: {
+        important: string[];
+    };
+    compose: (tools: ActionSchema[]) => string;
+};

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

@@ -0,0 +1,7 @@
+import { ActionSchema, BaseLLM } from "../../types";
+export declare class Orchestrator implements BaseLLM {
+    private readonly model;
+    tools: ActionSchema[];
+    constructor(tools: ActionSchema[]);
+    process(prompt: string): Promise<any>;
+}

package/dist/llm/orchestrator/index.js

@@ -0,0 +1,52 @@
+"use strict";
+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;
+    }
+    async process(prompt) {
+        try {
+            const response = await (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.object({
+                            name: zod_1.z.string(),
+                            value: zod_1.z.string(),
+                        }),
+                    })),
+                    answer: zod_1.z.string(),
+                }),
+                prompt: prompt,
+                system: context_1.orchestratorContext.compose(this.tools),
+            });
+            const validatedResponse = {
+                ...response.object,
+                actions: response.object.actions.map((action) => ({
+                    ...action,
+                    parameters: action.parameters || {},
+                })),
+            };
+            console.dir(validatedResponse, { depth: null });
+            return validatedResponse;
+        }
+        catch (error) {
+            if (error) {
+                console.log("Error in Orchestrator", error.message);
+                console.dir(error.value, { depth: null });
+                return {
+                    ...error.value,
+                };
+            }
+            // throw error;
+        }
+    }
+}
+exports.Orchestrator = Orchestrator;

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

@@ -0,0 +1,10 @@
+export declare const summarizerContext: {
+    role: string;
+    guidelines: {
+        important: string[];
+        forMarketAnalysis: string[];
+        forGeneralRequests: string[];
+        never: string[];
+    };
+    compose: (results: string) => string;
+};

package/dist/llm/synthesizer/index.d.ts

@@ -0,0 +1,14 @@
+import { StreamTextResult } from "ai";
+import { BaseLLM } from "../../types";
+export declare class Summarizer implements BaseLLM {
+    private readonly model;
+    process(prompt: string, onFinish?: (event: any) => void): Promise<{
+        actions: {
+            name: string;
+            result: string;
+            why: string;
+        }[];
+        response: string;
+    } | StreamTextResult<Record<string, any>>>;
+    streamProcess(prompt: string, onFinish?: (event: any) => void): Promise<StreamTextResult<Record<string, any>>>;
+}

package/dist/llm/synthesizer/index.js

@@ -0,0 +1,42 @@
+"use strict";
+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");
+    }
+    async process(prompt, onFinish) {
+        console.log("Summarizing results...");
+        const result = await (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(),
+                    result: zod_1.z.string(),
+                    why: 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;
+    }
+    async streamProcess(prompt, onFinish) {
+        const result = await (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/memory/index.d.ts

@@ -0,0 +1,21 @@
+import { CreateMemoryInput, MatchOptions, MemoryCacheOptions, MemoryScope } from "../types";
+export declare class MemoryCache {
+    private redis;
+    private readonly CACHE_PREFIX;
+    private readonly CACHE_TTL;
+    constructor(options?: MemoryCacheOptions);
+    private initRedis;
+    private getMemoryKey;
+    private storeMemory;
+    findBestMatches(query: string, options?: MatchOptions & {
+        userId?: string;
+        scope?: MemoryScope;
+    }): Promise<{
+        data: any;
+        similarityPercentage: number;
+        purpose: string;
+    }[]>;
+    private getAllMemories;
+    private getMemoriesFromKeys;
+    createMemory(input: CreateMemoryInput): Promise<string | undefined>;
+}